集合相关知识点

为什么学习集合？
数组，变量

• 之前的数据保存数组（长度是固定不变的，对数组的元素增加和删除操作起来非常麻烦），变量中
• 集合存储任意类型（基本包装类型，引用类型）
• 集合对元素的增删查改操作起来非常方便的，专门提供很多方便操作的方法
• 开发中经常集合来操作数据的，开发地位比较高的
• 考虑对数据的操作效率上的问题
• 概念？
• 把集合看做是一个容器
• 集合不是一个类，是一套集合框架，框架体系包含很多的集合类，java api提供了
• 集合保存各种类型的数据，很方便的操作
• 特点？
  1.关心集合是否可以存储null值
  2.关心集合是否可以唯一（是否允许重复）
  3.关心集合是线程安全的
  4.关心集合是否支持排序的
  5.关心集合是否有序，无序的
  6.关心集合的底层数据结构是什么（效率问题）
• 集合框架体系
• 单列集合

•  Collection接口父类
  

•      常用方法：
  

•      boolean add(E e)  添加一个元素的方法，添加成功，返回true
  

•      boolean addAll(Collection<? extends E> c)  添加一个集合
  

•       void clear()  清除元素
  

•       boolean contains(Object o)  是否包含指定的某个元素
  

•       boolean containsAll(Collection<?> c)  是否包含某个集合
  

•       boolean isEmpty()  是否为空，为空返回true，否则返回false
  

•       boolean remove(Object o)  删除某个元素
  

•       boolean removeAll(Collection<?> c)  删除某个集合
  

•       int size()  获取集合的长度
  

•       遍历方法：
  

•         Iterator<E> iterator() 集合提供的一个迭代器
  

•         Object[] toArray() 转成数组
  

•         <T> T[] toArray(T[] a) 泛型在后面讲解
  

•      List子接口类
  

•      Set子接口类
  

• 双列集合

•  Map
  

• 顶层父类
• 常用方法
• 遍历方法
• 工具类

/**

• Collection接口类方法
• List接口
• 添加

•   boolean add(E e) 添加一个元素
  

•   void add(int index, E element) 添加某个元素到指定位置
  

•   boolean addAll(Collection<? extends E> c) 添加一个集合
  

•   boolean addAll(int index, Collection<? extends E> c) 添加一个集合到指定位置
  

• 删除

•  E remove(int index) 删除指定位置的元素
  

•  boolean remove(Object o) 删除某个元素
  

•   boolean removeAll(Collection<?> c) 删除一个集合
  

• 修改

•   E set(int index, E element)
  

• 获取

•   E get(int index)
  

•  int size()
  

• 其他

•   int indexOf(Object o)
  

•   int lastIndexOf(Object o)
  

•    List<E> subList(int fromIndex, int toIndex)
  

• 遍历

•   E get(int index) + int size()
  

•  ListIterator<E> listIterator()
  

•  ListIterator<E> listIterator(int index)
  

/
/*

• 遍历

• •   E get(int index) + int size()
    

• •  ListIterator<E> listIterator()
    

• •  ListIterator<E> listIterator(int index)
    

•      iterator();
  

•      toArray();
  

•      foreach
  

•      toString
  

•      for()
  

•      for()
  

/
/*

 * 去除集合中重复的元素
 */
public class ListDemo03 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Employee(101,"张三",20,2000.0));
        list.add(new Employee(102,"李四",30,3000.0));
        list.add(new Employee(103,"王五",20,2000.0));
        list.add(new Employee(103,"王五",20,2000.0));
        //创建一个新的集合
//        List newList = new ArrayList();
//        for(Object obj : list){
//            if (!newList.contains(obj)){
//                newList.add(obj);
//            }
//        }
//        list = newList; //把新集合的数据赋值给到老集合
//        //遍历老集合
//        for(Object obj : list){
//            System.out.println(obj);
//        }

        //第二种去除重复的方式
        //冒泡，选择，比较equlas
        //根据选择排序的思想，从第一个元素依次和后面的每一个元素
        for (int i = 0; i < list.size(); i++) {
            for (int j = i+1; j < list.size(); j++) {
                //进行比较，如果第一个元素和第二个元素是相等
                //把第二个元素删除
                if (list.get(i).equals(list.get(j))){
                    list.remove(j);
                    j--;
                }
            }
        }
        for(Object obj : list){
            System.out.println(obj);
        }



    }
}

/**

• 泛型
• Collection集合都可以存储任意类型，Object，String，Integer，Double
• 1.需要做向下转型
• 2.为了提高安全性（解决风险性，类型没有确定，在做处理不是特别方便，可能会遇到异常，还需要做更多
• 的处理，比如判断之类，所以就会显得比较麻烦）
• 好处？
• 1.简化了代码
• 2.提高了安全性
• 3.规范类型
• 泛型分类
• 泛型类
• 泛型接口
• 泛型方法
• 定义泛型的时候，规范是如下
• 语法格式：,<A,B>
• 类型用大写的字母表示，A-Z
• 定义一个类型可以，定义多个类型也可以，以逗号之间隔开
• 泛型限定符
  /
  /*

 * 泛型接口
 */
public interface GenericeInterface<E,H> {
    void test1();
    E test2();
    H test3(E e);
}

//实现类，在实现泛型接口的时候，需要确定类型
class GenericeInterfaceImpl implements GenericeInterface<Integer,String>{

    @Override
    public void test1() {
        System.out.println("test1.............");
    }

    @Override
    public Integer test2() {
        return 100;
    }

    @Override
    public String test3(Integer integer) {
        System.out.println(integer);//10
        return "你好";
    }
}


public class TestGenericeInterface {
    public static void main(String[] args) {
        GenericeInterface<Integer,String> gif = new GenericeInterfaceImpl();
        gif.test1();
        Integer i = gif.test2();
        System.out.println(i);//100
        System.out.println(gif.test3(10));//10


    }
}

* 泛型方法
 */
public class GenericeMethod<G,H> {
    public void show1(H h){
        System.out.println(h);
    }
    //返回类型的时候，规定一种类型<类型>
    public <A> A show2(A h){
        return h;
    }
    public G show3(G g,H h){
        System.out.println(h);//java
        return g;//300
    }

}

public class TestGenericeMethod {
    public static void main(String[] args) {
        //在创建对象的时候，确定类型
        GenericeMethod<Integer,String> gm = new GenericeMethod<>();
        gm.show1("hello");
        Integer s = gm.show2(100);
        System.out.println(s);
        Integer i = gm.show3(300, "java");
        System.out.println(i);


    }
}

 * 定义的泛型类
 */
public class GenericeClass<E,T> {
    //属性
    private E e;
    private T t;

    public E getE() {
        return e;
    }

    public void setE(E e) {
        this.e = e;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}



public class TestGenericeClass {
    public static void main(String[] args) {
        //在使用泛型类的时候，需要确定类型
        GenericeClass<String,Integer> gc = new GenericeClass<>();
        gc.setE("hello"); //设置字符串类型
        System.out.println(gc.getE());//获取赋予字符串类型的值

        gc.setT(10); //设置整数类型的值
        System.out.println(gc.getT());
    }
}