集合1

集合的概念

 

• 当我们需要保存一组一样（类型相同）的元素的时候，我们应该使用一个容器来存储，数组就是这样一个容器。

数组有什么缺点？

数组一旦定义，长度将不能再变化。

● 然而在我们的开发实践中，经常需要保存一些变长的数据集合，于是，我们需要一些能够动态增长长度的容器来保存我们的数据。

● 而我们需要对数据的保存的逻辑可能各种各样，于是就有了各种各样的数据结构。Java中对于各种数据结构的实现，就是我们用到的集合。

集合 API

集合体系概述 ：

Java的集合框架是由很多接口、抽象类、具体类组成的，都位于java.util包中。

 

collection接口

● Collection 接口－定义了存取一组对象的方法，其子接口Set和List分别定义了存储方式。

● Set 中的数据对象没有顺序且不可以重复。

● List 中的数据对象有顺序且可以重复。

Collection<E>集合可以使用泛型向集合中传入一个参数，如果不传默认是Object,都必须存储引用类型

public static void main(String[] agrs){
Collection c = new ArrayList();//默认是Object类型
           c.add("a");
           c.add(1);//自动装箱为包装类型
           c.add(true);
​
}

在Java中存储为Object可以，但是实际取出时必须给出具体的类型，即向下转型时存在很大的安全隐患，因此建议使用泛型给出具体的类型。

eg：Collection <String> c = new ArrayList<String>();

 public static void main(String[] args) {
​
        Collection<String> c = new ArrayList<String>();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        c.add("e");
        //c.remove("a");//删除指定的元素，第一次出现的
        //c.clear();//清空
        System.out.println(c.isEmpty());//是否为空
        System.out.println(c.contains("a"));//是否包含
        System.out.println(c.size());
        System.out.println(c);
​
        Object[] objs1 = c.toArray();//集合转数组
        System.out.println(Arrays.toString(objs1));
​
        String[] objs2 = c.toArray(new String[c.size()]);//集合转数组,可以指定集合的类型
    }

  public static void main(String[] args) {
            Collection<String> c = new ArrayList<String>();
            c.add("a");
            c.add("b");
            c.add("c");
            c.add("d");
            Collection<String> c1 = new ArrayList<String>();
            c1.add("a");
            c1.add("b");
            c1.add("c");
​
            c.addAll(c1);
            c.removeAll(c1);//删除了c1在c中的内容
        System.out.println(c.containsAll(c1));
        System.out.println(c.retainAll(c1));//只保留c与c1相交的部分，元素发生变化返回true，不发生变化返回false
    }
​
       

泛型

为什么用泛型？

早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

什么是泛型？

● 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。

● 参数化类型，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式，然后在使用/调用时传入具体的类型。

泛型类

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法.

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。

一个最普通的泛型类：

public class Demo<T>{ / /T可以为任意标识符，常见的如T、E、K、V等形式的参数常用于表示泛型

private T key; / /key这个成员变量的类型为T,T的类型由外部指定

public Generic(T key) { / /泛型构造方法形参key的类型也为T，T的类型由外部指定

this.key = key;

}

public T getKey(){ / /泛型方法getKey的返回值类型为T，T的类型由外部指定

return key;

}

}

传入的实参类型需与泛型的类型参数类型相同，即为Integer.

Demo<Integer> genericInteger = new Demo<Integer>(123456);

1.泛型的类型参数只能是类类型 2.泛型的类型参数可以有多个。3.如果没有定义具体类型,默认为Object从泛型类派生子类

子类也是泛型类，子类和父类的泛型类型要一致

class A<T> extends Demo<T>

子类不是泛型类，父类要明确泛型的数据类型

class A extends Demo<String>泛型接口

泛型接口与泛型类的定义及使用基本相同。

public interface Demo<T> { //定义一个泛型接口

public T next();

}

子类也是泛型类，子类和父类的泛型类型要一致

class A<T> implements Demo<T>{

@Override

public T next() {

return null;

}

}

泛型通配符

● 什么是类型通配符？

● 类型通配符一般是使用"？"代替具体的类型实参。

● 所以，类型通配符是类型实参，而不是类型形参。

public void showKeyValue1(Demo<Number> obj){

}

Demo<Integer> gInteger = new Demo<Integer>(123);

Demo<Number> gNumber = new Demo<Number>(456);

showKeyValue(gNumber);

showKeyValue(gInteger);这个方法编译器会为我们报错：Generic<java.lang.Integer>

泛型通配符

● 类型通配符上限

类/接口<？extends实参类型>

要求该泛型的类型，只能是实参类型，或实参类型的子类类型。

● 类型通配符下限

类/接口<？super实参类型>

要求该泛型的类型，只能是实参类型，或实参类型的父类类型。

类型擦除

泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好地和之前版本的代码兼容。那是因为，泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。

List<String> l1 = new ArrayList<String>();

List<Integer> l2 = new ArrayList<Integer>();

System.out.println(l1.getClass() == l2.getClass());

打印的结果为 true 是因为 List<String>和 List<Integer>在 jvm 中的 Class 都是 List.class。

泛型信息被擦除了。

泛型类被类型擦除后，相应的类型就被替换成 Object 类型或者上限类型类型擦除

案例:

public class Erasure <T>{

T object;

public Erasure(T object) {

this.object = object;

}

}

Erasure 是一个泛型类，我们查看它在运行时的状态信息可以通过反射。

Erasure<String> erasure = new Erasure<String>("hello");

Field[] fs = eclz.getDeclaredFields();

for ( Field f:fs) {

System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());

}

Field name object type:java.lang.Object

List 接口及实现类

● List继承了Collection接口,有三个实现的类

－ ArrayList 底层实现是数组结构，线程不安全

数组列表，数据采用数组方式存储。

－LinkedList 底层是链表结构

链表

－Vector 底层是数组实现，是线程安全的

数组列表，添加同步锁,线程安全的

 

ArrayList 查询块，增删慢

public static void main(String[] args){
​
ArraysList<String> alist = new ArraysList<>();//创建一个长度为10的底层数组，第一次添加元素时，真正创建数组
ArraysList<String> alist = new ArraysList<>(20);//创建长度为20的数组
                   alist.add("a");
                   alist.add("b");
                   alist.add("c");
                   alist.add(0,"d");//向指定位置插入数据
                   alist.set(1，"B");//替换指定位置的元素
      System.out.println(alist.get(2));//返回此列表中指定的元素
      System.out.println(alist.indexof("b"));//返回此列表中指定元素的第一次出现的索引，如果此列表不包含此元素，则返回-1
      System.out.println(alist.remove(1));//删除并返回指定索引的元素
      System.out.println(alist);
}

public class ArrayListDemo3 {
    
     public static void main(String[] args) {
         
         
         ArrayList<String> alist = new ArrayList<>(); 
                       
                           alist.add("c");
                           alist.add("b");
                           alist.add("a");
                           alist.add("d");
                //new 接口(){ 方法重写  } 创建了一个匿名内部类对象      
               /*alist.sort(new Comparator<String>() {
                @Override
                public int compare(String o1,String o2) {
                return o1.compareTo(o2);
                  }
                }); */    
                           
                      //创建了一个自定义String比较器类的对象     
                     // alist.sort(new StringComparator());     
                
 //alist.sort((String o1,String o2)->{ return o1.compareTo(o2); });  
                    
                     System.out.println(alist);
                           
    }
}
结果：[a,b,c,d]
​
//自定义String比较器
package com.ffyc.javaCollection2.day1.list;
​
import java.util.Comparator;
​
public class StringComparator implements Comparator<String>{
​
    @Override
    public int compare(String o1, String o2) {
         
        return o1.compareTo(o2);
    }
​
}
​

 

LinkedList 查询慢，增删快

public static void main(String[] args){
​
LinkedList<String> llist = new LinkedList();
                   llist.add("a");
                   llist.add("b");
                   llist.add("c");
                   llist.add("d");
                   llist.add("a");
                   //index<size/2从头结点开始向后找，否则从尾结点向前找
                   System.out.println(llist.get(3));
                   System.out.println(llist);
​
}

 

Vector 底层也是数组实现，但是是线程安全的

public static void main(String[] args){
​
Vector<String> v = new Vector();
               v.add("a");
               v.add("a");
               v.add("a");
               v.add("a");
               v.add("a");
               v.add("a");
               System.out.println(v)
}

List接口集合迭代

public static void main(String[] args){
​
ArrayList<String> alist = new ArrayList();
               alist.add("a");
               alist.add("b");
               alist.add("c");
               alist.add("d");
      
//for循环遍历      
      for(i=0;i<alist.size();i++){
         System.out.println(alist.get(i));
         }
   
   /*for
      支持在遍历的过程删除集合中的元素，注意元素向前移动，i++，会漏掉元素
     */
  ArrayList<String> alist = new ArrayList();
               alist.add("a");
               alist.add("a");
               alist.add("a");
               alist.add("b");
               alist.add("c");
               alist.add("d");   
               for(i=0,i<alist.size();i++){
                    if(alist.get(i).equals("a")){
                           alist.remove(i);
                        }
                   }
           System.out.println(alist);          
结果：[a,b,c,d]                        
               
​
​
//增加for
      for(String s: alist){
         System.out.println(s);
         }
     
     /*
          增强for循环
           不支持在遍历时删除元素
      */         
           for(String s: alist){
          if(s.equals("a")){
             alist.remove(s);
             break;
          }
         }
         System.out.println(alist);
结果：[a,a,b,c,d]    
    
         
//通过迭代器
      Iterator<String> it = alist.iterator();//返回一个迭代器对象，控制元素的遍历
                 while(it.hasNext()){
                 String s = it.next();
                 System.out.println(s);
                 }
   /*
   通过迭代器
   */
  
      Iterator<String> it = alist.iterator();
                 while(it.hasNext()){
                 String s = it.next();
                 if(s.equals("a")){
                  it.remove();//使用迭代器中的方法进行遍历
                 }
                 }
       
结果：[b,c,d]
​
​
//listIterator()  只能对List接口下的实现类进行遍历 
从前先后：
                ListIterator<String> lit = alist.listIterator();
                 while(lit.hasNext()){
                 System.out.println(lit.next());
                 }
从后先前：                 
          ListIterator<String> lit = alist.listIterator(alist.size());
                 while(lit.hasPrevious()){
                 System.out.println(lit.previous());
                 }
}
​

Set接口

● Set接口继承了Collection接口。

Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的

● Set接口有两个实现类

● HashSet

HashSet类中的元素不能重复，即彼此调用equals方法比较，都返回false。

底层数据结构是哈希表+链表

哈希表依赖于哈希值存储

● TreeSet

可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。

TreeSet底层数据结构是二叉树(红黑树是一种自平衡的二叉树)

HashSet

HashSet中添加元素时如何去除重复元素？

判断要求是即快又安全。

System.out.println("abc".equals("abc"));equals判断安全但效率低。

怎样提高比较速度？

使用内容的hash值比较（哈希值是整数），但是哈希值不安全（有可能内容不同，哈希值相同）

最终解决方案就是先用内容计算的哈希值比较，如果出现了相同的哈希值，那么再调用equals方法判断内容分是否相同

TreeSet

public static void main(String[] args){
​
  TreeSet<String> tset = new TreeSet();
                  tset.add("s");
                  tset.add("a");
                  tset.add("c");
                  tset.add("b");
                  tset.add("d");
                  tset.add("s");
                  System.out.println(tset);
}
结果：[a,b,c,d,s]
​

遍历方式：

增强for循环 和 迭代器遍历