collection 集合

Collection接口常用的子接口有：List接口、Set接口

List接口常用的子类有：ArrayList类、LinkedList类

Set接口常用的子类有：HashSet类、LinkedHashSet类

常用集合类的继承结构如下：
Collection(接口)<–List(接口)<–Vector
Collection(接口)<–List(接口)<–ArrayList
Collection(接口)<–List(接口)<–LinkedList
Collection(接口)<–Set(接口)<–HashSet(实现类)
Collection(接口)<–Set(接口)<–HashSet(实现类) <–LinkedHashSet (实现类)
Collection(接口)<–Set(接口)<–SortedSet(接口)<–TreeSet(实现类)
Map(接口)<–SortedMap(接口)<–TreeMap(实现类)
Map(接口)<–HashMap(实现类)

Collection
|–List
有序(存储顺序和取出顺序一致)，可重复
|–Set
无序(存储顺序和取出顺序不一致，但它有自己的存储顺序)，唯一

牢记：
ArrayXxx:底层数据结构是数组，查询快，增删慢
LinkedXxx:底层数据结构是链表，查询慢，增删快
HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

原文链接：https://blog.csdn.net/qq_31360933/article/details/79337483

 Collection是接口不能new对象所以的多态借用子类对象:

格式：创建集合的格式：

方式1：Collection<元素类型> 变量名 = new ArrayList<元素类型>();

方式2：Collection 变量名 = new ArrayList();

ArrayList继承了AbstractList同时又实现接口List,而List接口又继承了Collection接口,Collection是集合中最顶层的接口了;Collection是所以集合的祖宗
List接口:怎么存就怎么取,有数组下标,可以存重复元素:  

常有的类:ArrayList类;  LinkedList类;
Set接口:怎么存的不一定怎么取,没有数组下标,不可以存重复数据   ;

 

//往集合中添加对象元素。add(E e)方法，E代表创建集合时所指定的数据类型如<String>，那么，E就代表String类型；创建集合时若没有指定数据类型，那么，E就代表Object类型。

ArrayList<Person> list =new ArrayList<Person> ();
       list.add(new Person("胡德正",12));
       list.add(new Person("姜发财",25));
       //遍历
       for(int i=0;i<list.size();i++) {
        System.out.println(list.get(i));        
       }

/*这里直接添加了Person对象,因为重写构造方法所以直接赋值
System.out.println(list.get(i)) 如果Person类中没有重写toString方法那么这里打印的是地址;但是Person重写了tostring方法那么这里打印的方法内的内容*/

Collection<Integer> col=new ArrayList<Integer>();

因为Collection是接口不能new对象所以这里借用了子类ArrayList创建对象,是多态

Collection的基本操作:

1.添加元素:col.add(123);

2.删除元素:col.remove(123);这里删除直接写集合内要删除的内容不需要写下标
3.清空集合:col.clear;把集合中的内容删了,但是集合还在

.因为Collection是接口不能new对象所以的向下转型才能遍历集合:

   Collection<Integer> col =new ArrayList<Integer>();
     col.add(123);
    col.add(456);
    col.add(789);

     //删除元素
       col.remove(456);
       //清空集合
      col.clear
//是多态需要向下转型遍历

     if(col instanceof ArrayList)  ArrayList<Integer> list=(ArrayList<Integer>)col;

     for(int i=0;i<list.size();i++) {

        System.out.println(list.get(i));
     }
//判断集合中是否包含某个元素
     boolean flag=col.contains(999);
     System.out.println(flag);
     //将集合转为数组  转型
     Object[] arr=col.toArray();
     for(int i=0;i<arr.length;i++) {
        System.out.println(arr[i]);    
     }
集合转为数组:Object arr=col.toArray();因为Collection的.toArray()方法返回值是Object所有用Object arr接
再进行遍历值:for(inti=0;i<arr.length;i++){system.out.println(arr[i])};

 

Iterator迭代器

Collection获取集合内的元素是通过迭代器实现的:

定义：迭代器对象Iterator会先对Collection进行判断用.hasnext()方法进行判断如果有就返回true没有就返回false;

如果.hasNext()返回的是true那么再调用.next()方法把Collection中的值取出来,迭代器取值是判断一次去一次值;然后再判断再取值

Collection<String> col = new ArrayList<String>();
     col.add("将发财");
     col.add("胡德正");
     col.add("吾皇");

     //首先 获取迭代器对象
     Iterator<String> it = col.iterator();

//遍历和上面一样、

//判断
     while(it.hasNext()){

       //如果为true 则取元素
       String str=it.next();

//进行比较
       if(str.equals("哪吒")) {
       System.out.println(str);}    

     }

/*取值需要先获取迭代器对象:
Iterator<String> it=col.iterator();
调用Collection的对象col调取iteartor()方法获取迭代器对象;

再赋值给it;
迭代器Iterator的泛型要和 Collection要被遍历的集合一样;

it.hasNext()是判断集合中是否还有值有就返回true再调用it.next()方法取值,没有就返回false然后结束

在利用迭代器循环取值:*/
while(it.haxnext()){system.out.println(it.next())};

while循环里面条件只有true和false那么默认就true所以it.haxnext()就是it.haxnext()==true
利用判读字符内容来取值:

while(it.hasnext()){String str="哪吒"

;if(str.equals("哪吒")){

system.out.println(str)

}

/*判断字符是哪吒后再输出;一定先定义和变量;再判断输 出变量;

因为collection是先判断有没有值然后再取值的所以的先定义个变量str接收了才能保存住要不然输出的是下一个值*-/

泛型
集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

Collection col=new ArrayList();//如果不加泛型,就可以什么都向集合存，不加泛型自动转成Object类型
col.add(123);//不加泛型系统自动把值提升为object类型
col.add("123");
col.add(123.456);
//获取迭代器对象
Iterator it=col.iterator();//因为上面的集合没写泛型所以这里迭代器对象也不写泛型
while(it.hasNext()){
Object obj=it.next();//因为集合里没写泛型值都生成Object;所以这里也用Object来接
if(obj instanceof String){
String s=(String)obj;//转成字符串
System.out.println(s.length());
}
}

增强for

public static void main(String[] args) {

    //容器
    Collection<String> col=new ArrayList<String>();//定义为String 类型

    //存值
    col.add("a");
    col.add("b");
    col.add("c");

    //自定义类型用for方便
    //增强for循环,不通过下标，底层有迭代器，增强for迭代器中不能改变集合长度（曾 删操作）；普通for可以改变

    for(String s:col ) {

        System.out.println(s);

    }

}

增强for:

   专门用来变量数组和集合的(没有下标)不能打印有下标的集合数组(打印1-100的值);

  它的内部原理是迭代器Interator,所以在打印过程中不能对集合中的元素
进行增删,但可以修改;只要不改变集合/数组的长度都行.
格式:个人理解

for(要遍历的元素类型(String)  变量名(p): Collection集合or数组(arr))

{system.out.println(p)};

格式：

for(元素的数据类型 变量 : Collection集合or数组){

}

增强for和老式的for循环的区别:

增强for的循环必须要有目标,且目标只能是Collection的数组和集合,在遍历时如果只是对数组和集合进行遍历那么就用增强for
如果还需要对数组和集合的元素进行操作那么就用老式for循环,通过对下标的操作进行增删改;

 

public static void main(String[] args) {

  Collection<Person> col=new ArrayList<Person>();
   col.add(new Person("傲丙",18));
   col.add(new Person("金吒",28));
   col.add(new Person("木栅",15));
   for(Person ss:col) {内置原理是迭代器Interator,先判断col集合里面是否有值(has.next())再进行取值(.next())然后把取到的值赋给s;
                         再打印是;然后再判断,再取值,再复制,打印

     System.out.println(ss);

     这里是增强for打印自定义的Person类,把col的值赋值到Person类型的p对象里面,然后再打印p,
          因为Person重写了toString()方法所以这里打印的toString()方法里面的内容而不是地址

   }   

增强for和迭代器不能增删但是可以修改,只有不改变集和的长度就行,如果想增删改就用老式for,因为增强for和迭代器一样一直往下走不能回头,就不能改变长度 

 泛型的定义与使用

用一个方法遍历多种Collection集合,（通配符<?>;当做泛型）

public static void main(String[] args) {

  //重写toStrion调用本类方法，不重写就调用Object中的方法

  Collection<Person> col=new ArrayList<Person>();
  col.add(new Person("善思",12));
  col.add(new Person("章鱼",45));

  Collection <Student> col2= new ArrayList<Student>();
  col2.add(new Student("夏","女"));
  col2.add(new Student("商","男"));

  //调用同一方法，遍历集合

  get(col);
  get(col2);

}

  //泛型通佩符号？
public static void get( Collection<?> col) {   // (Collection<?> col)中的?是通配符,在不知道泛型是什么的时候就有?代替泛型这样就能调用多种collection泛型的集合
  //获取迭代器，因为重写了 tostring古it打印字符
  Iterator<?> it=col.iterator();

曾强for不能遍历带有通配符?的集合,因为增强for不认识通配符?;只能用迭代器进行遍历

  while(it.hasNext()) {
     System.out.println(it.next()) 
  }
}

 

 

 

 

泛型限定

 

public static void main(String[] args) {

     Collection<cook> coll = new ArrayList<cook>();

     coll.add(new cook());

     Collection<waiter> col2 = new ArrayList<waiter>();

     col2.add(new waiter());

     // 调用同一方法，打印cook ,waiter类

     get(coll);

     get(col2);

 

  }

 

       //<? extends emp>泛型上线   <? super emp> 下线  至少是emp

  public static void get(Collection<? extends emp> col) {

/*就是extends表示必须是继承Emp的子类和Emp才能传过来;

super意思是Emp是这个父类最底层的子类,只能是Emp的父类们 (父类,爷爷类)和它自己Emp才能传过来*/

     Iterator<?> it = col.iterator();

/*//Collection<? extends Emp>这里是传的继承Emp的子类及其Emp;是上限的意思;上限时Emp
*/

     while (it.hasNext()) {

/*Collection<? super Emp>这里传的是Emp的父类及其Emp;是下限的意思;下限时Emp*/

       System.out.println(it.next());

//因为不设置上下线有通配符?存在所以传什么类都行,这样就进行了限制

     }

 

  }

}

 

1.1      泛型限定

上述打印集合的功能，看似很强大，可以打印任意集合，可是问题也来了。如果想要对被打印的集合中的元素类型进行限制，只在指定的一些类型，进行打印。怎么做呢？

要解决这个问题，我们就要学习泛型的限定。

限定泛型的上限：

格式：? extends E

? 代表接收E类型或者E的子类型的元素

例如，泛型限定为：? extends Person

则 ? 代表接收Person类型或者Person子类型的元素

限定泛型的下限：

格式：? super E

? 代表接收E类型或者E的父类型的元素

例如，泛型限定为：? super Student

则 ? 代表接收Student类型或者Student父类型的元素