Java学习笔记总结——集合框架

集合的概念（什么是集合？）

集合就是对象的容器，它实现了对对象常用的 *** 作，类似数组功能。

集合与数组的区别

1. 数组长度固定，而集合长度不固定。
2. 数组可以存储基本类型和引用类型，而集合只能存储引用类型

Collection体系集合

Collection是体系的根接口，代表一组对象，称为“集合”。

Collection它所存放的是单一值

• Collection父接口的特点：代表一组任意类型的对象，无序、无下标、不能重复。
• List接口的特点：有序、有下标、元素可重复。
• Set接口的特点：无序、无下标、元素不能重复。

同时它有以下几个特点：

1. 当使用Arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容 *** 作。
2. 它可以存放不同类型的数据，而数组只能存放固定类型的数据。

api方法：
     增加数据的方法：

1.                add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程。
2.                addAll:添加另一个集合的元素到此集合中。

         删除数据的方法：

1.                  clear:只是清空集合中的元素，但是此集合对象并没有被回收
2.                  remove:删除指定元素
3.                  removeAll：删除集合元素

          查询数据的方法：

1.                  contains:判断集合中是否包含指定的元素值
2.                  containsAll:判断此集合中是否包含另一个集合
3.                  isEmpty:判断集合是否等于空
4.                  retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
5.                  size:返回当前集合的大小

package collection.class4;
 
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
 
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(1); //new Integer(1)
        collection.add("123"); // new String("123")
        collection.add(true);  //new Boolean(true)
        System.out.println(collection);
 
        Collection collection1 = new ArrayList();
        collection1.add("abc");
        collection1.add(666);
        collection1.add(false);
        collection.addAll(collection1);
        System.out.println(collection);
        System.out.println(collection.contains("abc"));
        System.out.println(collection.isEmpty());
System.out.println(collection.size());
        Object[] objects = collection.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
    }
}

Arraylist的使用： 

• 存储结构：数组、查找遍历速度快，增删数据慢(特点)
• JDK1.2版本，运行效率快、线程不安全

        

ArrayList源码分析

1.     默认容量大小：private static final int DEFAULT_CAPACITY = 10;
2.     存放元素的数组：transient Object[] elementData;
3.     实际元素个数：private int size;
4.     创建对象时调用的无参构造函数：
    

     

public class Demo5 {
	public static void main(String[] args) {
		ArrayList arrayList=new ArrayList<>();
		//1.添加元素
		Student s1=new Student("程", 21);
		Student s2=new Student("大", 22);
		Student s3=new Student("虎", 21);
		arrayList.add(s1);
		arrayList.add(s2);
		arrayList.add(s3);
		System.out.println("元素个数："+arrayList.size());
		System.out.println(arrayList.toString());
		//2.删除元素
		arrayList.remove(s1);
		//arrayList.remove(new Student("程", 21));
		//注：这样可以删除吗（不可以）？显然这是两个不同的对象。
		//假如两个对象属性相同便认为其是同一对象，那么如何修改代码？
		//3.遍历元素
		//3.1使用迭代器
		Iterator iterator=arrayList.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		//3.2使用列表迭代器
		ListIterator listIterator=arrayList.listIterator();
		//从前往后遍历
		while(listIterator.hasNext()) {
			System.out.println(listIterator.next());
		}
		//从后往前遍历
		while(listIterator.hasPrevious()) {
			System.out.println(listIterator.previous());
		}
		//4.判断
		System.out.println(arrayList.isEmpty());
		//System.out.println(arrayList.contains(new Student("虎", 22)));
		//5.查找
		System.out.println(arrayList.indexOf(s1));
	}
}

泛型的使用

泛型概述

• Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
• 常见形式有泛型类、泛型接口、泛型方法。
• 语法：
  • T称为类型占位符，表示一种引用类型。
• 好处：
  • 提高代码的重用性。
  • 防止类型转换异常，提高代码的安全性。

package collection.class4;
 

public class FanXingClass {
 
    private String name;
 
    private A a;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public A getA() {
        return a;
    }
 
    public void setA(A a) {
        this.a = a;
    }
 
    public void show(){
        System.out.println("name: " + name + " A:" + a);
    }
 
    public void set(A a){
        System.out.println("这是set方法中的A" + a);
    }
 
    public A get(){
        return a;
    }
}

当做一些集合的统一 *** 作的时候，需要保证集合的类型是统一的，此时需要泛型来进行限制

                泛型的优点：

1. 数据安全性高。
2. 获取数据时效率比较高。

使用方法:

在定义对象的时候，通过<>中设置合理的类型来进行实现泛型的高阶应用:

• 泛型类：

在定义类的时候在类名的后面添加,起到占位的作用，类中的方法的返回值类型和属性的类型都可以使用

• 泛型接口：

            在定义接口的时候，在接口的名称后添加

1.            子类在进行实现的时候，可以不填写泛型的类型，此时在创建具体的子类对象的时候才决定使用什么类型
2.            子类在实现泛型接口的时候，只在实现父类的接口的时候指定父类的泛型类型即可，此时，测试方法中的泛型类型必须要跟子类保持一致

       泛型方法

           在定义方法的时候，指定方法的返回值和参数是自定义的占位符，可以是类名中的T,也可以是自定义的Q，只不过在使用Q的时候需要使用定义在返回值的前面

•        泛型的上限（工作中不用）

           如果父类确定了，所有的子类都可以直接使用

•        泛型的下限（工作中不用）

           如果子类确定了，子类的所有父类都可以直接传递参数使用

 
 

import java.util.ArrayList;
import java.util.List;
 
public class FanXingDemo {
 
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("1");  //new Integer(1)
        list.add("123");  // new String("123")
        list.add("true");  //new Boolean(true)
//
//        //遍历集合
//        for (int i = 0; i < list.size(); i++) {
//            System.out.println(list.get(i));
//        }
//
//        System.out.println("***************************************");
//        for(String o : list){
            String str = (String)o;
//            System.out.println(o);
//        }
 
//        FanXingClass fanXingClass = new FanXingClass();
//        fanXingClass.setNum(1);
//        fanXingClass.setA("123");
//        fanXingClass.show();
//
//        FanXingClass fanXingClass2 = new FanXingClass();
//        fanXingClass2.setNum(2);
//        fanXingClass2.setA(1234);
//        fanXingClass2.show();
//
//        FanXingClass fanXingClass3 = new FanXingClass();
//        fanXingClass3.setNum(3);
//        fanXingClass3.setA(new Person("小白",18));
//        fanXingClass3.show();
//
//        FanXingClass fanXingClass4 = new FanXingClass();
//        fanXingClass4.setNum(4);
//        fanXingClass4.set("666");
//        fanXingClass4.setA("8888");
//        System.out.println(fanXingClass4.get());
//        fanXingClass4.show();
 
//        FanXingInterface fanXingInterface = new FanXingInterfaceImpl();
//        fanXingInterface.test2("666");
//        System.out.println(fanXingInterface.test());
 
        FanXingMethod fanXingMethod = new FanXingMethod();
        fanXingMethod.setT("666");
        fanXingMethod.show(123);
        fanXingMethod.show(true);
    }
}

FanXingInterface

package collection.class4;

  public abstract void test(B b);
 
  public abstract B test2();
 
}

FanXingMethod

package collection.class4;
 
public class FanXingMethod {
 
    private int id;
 
    private T t;
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public T getT() {
        return t;
    }
 
    public void setT(T t) {
        this.t = t;
    }
 
    public  void show(Q q){
        System.out.println(t);
        System.out.println(q);
    }
}

一、Iterator的使用

在java代码中包含三种循环的方式

•     do...while
•     while
•     for

  还有一种增强for循环的方式，可以简化循环的编写
    所有的集合类都默认实现了Iterable的接口，实现此接口意味着具备了增强for循环的能力，也就是for-each
     增强for循环本质上使用的也是iterator的功能
       方法：

•                 iterator()
•                 foreach()

    在iterator的方法中，要求返回一个Iterator的接口子类实例对象
        此接口中包含了
                hasNext()
                next()
 
    在使用iterator进行迭代的过程中如果删除其中的某个元素会报错，并发 *** 作异常，因此
        如果遍历的同时需要修改元素，建议使用listIterator（），
    ListIterator迭代器提供了向前和向后两种遍历的方式
        始终是通过cursor和lastRet的指针来获取元素值及向下的遍历索引
        当使用向前遍历的时候必须要保证指针在迭代器的结果，否则无法获取结果值
 

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class IteratorDemo {
 
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add("123");
        list.add(true);
        list.add(100L);
        list.add(10.0d);
        //遍历集合
//        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
 
        System.out.println("*******************");
        //使用迭代器
//        Iterator iterator = list.iterator();
        ListIterator listIterator = list.listIterator();
        while(listIterator.hasNext()){
//            if(list.contains("123")){  并发操作异常
//                list.remove("123");
//            }
//            Object o = listIterator.next();
//            if("123".equals(o)){
//                listIterator.remove();
//            }
            System.out.println(listIterator.next());
        }
//        System.out.println(list);
 
//        System.out.println("*******************");
//        //增强for循环
//        for(Object i :list){
//            System.out.println(i);
//        }
        System.out.println("*********************************");
        while(listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
 
    }
}

二、LinkedList的使用

链表结构实现，增删快，查询慢。

LinkedList源码分析

LinkedList首先有三个属性：

•  链表大小：transient int size = 0;
• （指向）第一个结点/头结点：transient Node first;
• （指向）最后一个结点/尾结点：transient Node last;

LiKedListDeom

package collection.class4;
 
import java.util.LinkedList;
 
 
/*
 * linkedList拥有更加丰富的方法实现，需要用的时候查询api即可，不需要记忆
 *
 * */
public class LinkedListDemo {
 
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(1);
        list.add("abc");
        list.add(true);
        list.add("abc");
        list.add(100L);
        System.out.println(list);
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        list.addFirst("ok");
        System.out.println(list);
//        System.out.println(list.peek());
//        System.out.println(list);
//        System.out.println(list.poll());
//        System.out.println(list);
//        System.out.println(list.pop());
//        System.out.println(list);
        list.push("no");
        System.out.println(list);
 
 
 
 
    }
}

List的使用

java集合框架：
        List：存放的是单一值
       特点：

1.             可以存放不同类型的数据，而数组只能存放固定类型的数据
2.             当使用Arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容 *** 作

        api方法：
            增加数据的方法
            add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程
            addAll:添加另一个集合的元素到此集合中
 
            删除数据的方法
            clear:只是清空集合中的元素，但是此集合对象并没有被回收
            remove:删除指定元素
            removeAll：删除集合元素
 
           查询数据的方法
            contains:判断集合中是否包含指定的元素值
            containsAll:判断此集合中是否包含另一个集合
           isEmpty:判断集合是否等于空
           retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
          size:返回当前集合的大小
 
            //集合转数组的 *** 作
            toArray:将集合转换成数组

import java.util.ArrayList;
import java.util.List;
public class ListDemo {
 
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(123);
        list.add("abc");
        list.add(18.0);
        list.add(true);
        list.add(18.0);
        System.out.println(list);
        list.add(0,"ok");
        System.out.println(list);
        Object o = list.get(0);
        System.out.println(o);
        System.out.println(list.indexOf(18.0));
        System.out.println(list.lastIndexOf(18.0));
        System.out.println(list.size());
//        list.remove(1);
//        System.out.println(list);
        list.set(4,false);
        System.out.println(list);
        System.out.println(list.subList(1,4));
 
 
    }
}

3、Vector的使用

• 数组结构实现，查询快、增删慢；
• JDK1.0版本，运行效率慢、线程安全。Vector
  • 数组结构实现，查询快、增删慢；
  • JDK1.0版本，运行效率慢、线程安全。

import java.util.Vector;
public class VectorDemo {
 
    public static void main(String[] args) {
        Vector vector =new Vector();
        vector.add(123);
        vector.add("123");
        vector.add(true);
        vector.add(100L);
        System.out.println(vector);
        System.out.println(vector.firstElement());
    }
}

三、Set的使用

• 特点：无序、无下标、元素不可重复。

• 方法：全部继承自Collection中的方法。

•   set不可以通过下标获取对应位置的元素的值，因为无序的特点
•   使用Treeset底层的实现是Treemap,利用红黑树来进行实现
•   设置元素的时候，如果是自定义对象，会查找对象中的equals和hashcode的方法，如果没有，比较的是地址
•   树中的元素是要默认进行排序 *** 作的，如果是基本数据类型，自动比较，如果是引用类型的话，需要自定义比较器

       比较器分类：
         内部比较器:
                定义在元素的类中，通过实现Comparable接口来进行实现
         外部比较器:
               定义在当前类中，通过实现Comparator接口来实现，但是要将该比较器传递到集合中 

         注意：外部比较器可以定义成一个工具类，此时所有需要比较的规则如果一致的话，可以复用，而 内部比较器只有在存储当前对象的时候才可以使用 如果两者同时存在，使用外部比较器当使用比较器的时候，不会调用equals方法

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
 
public class SetDemo implements Comparator {
 
    public static void main(String[] args) {
//        Set set = new HashSet();
//        set.add(1);
//        set.add("abc");
//        set.add(true);
//        set.add(100L);
//        set.add("abc");
//        System.out.println(set);
 
        //遍历集合
//        for (int i = 0; i < set.size(); i++) {
//            System.out.println(set.get);
//        }
 
        //迭代器遍历
//        Iterator iterator = set.iterator();
//        while(iterator.hasNext()){
//            Object obj = iterator.next();
//            System.out.println(obj);
//        }
 
        //增强for循环
//        for(Object o : set){
//            System.out.println(o);
//        }
 
//        System.out.println("*******************************");
//        for(Iterator iterator1 = set.iterator();iterator1.hasNext();){
//            System.out.println(iterator1.next());
//        }
 
//        Set set = new TreeSet();
//        set.add(1);
//        set.add(123);
//        set.add(5);
//        set.add(20);
//        set.add("abc");
//        set.add("casd");
//        set.add("dasd");
//        set.add("bfh");
//        System.out.println(set);
 
        Set set = new TreeSet(new SetDemo());
        set.add(new Person("zhangfei",19));
        set.add(new Person("guanyu",20));
        set.add(new Person("zhaoyun",18));
        set.add(new Person("mashaladi",30));
        System.out.println(set);
    }
 
    @Override
    public int compare(Object o1, Object o2) {
        Person p1 = (Person)o1;
        Person p2 = (Person)o2;
        if(p1.getAge() > p2.getAge()){
            return -1;
        }else if(p1.getAge() < p2.getAge()){
            return 1;
        }else{
            return 0;
        }
    }
}