容器相关笔记

以下表格基于Collection list = new ArrayList();

名形参返回值性质例子作用

add 要存入的对象非静态 list.add("asd") 插入一个元素

iterator "Iterator对象" 非静态 Iterator i = list.iterator 获取迭代器对象

size int 非静态 int a = list.size(); 获取容器长度

isEmpty boolean 非静态 boolean b = list.isEmpty(); 判断容器是否为空

contains 非静态对象 boolean
String temp = new String("zjh");

System.out.println("contains:\t"+list.contains(temp));
看看容器中是否有temp对象

remove 非静态对象 list.remove(”asd“); 按照对象内容指定删除

为什么要用容器而不直接使用数组来存储。数组存储单一的类型而且数组需要规定长度，但是容器不需要而且可以在一个容器中存储多种不同的数据类型

迭代器的作用是获取容器中的对象

迭代器就是用来获取一个有个的对象的

所以想要拿出来容器的数据就要用Collection父类的iterator方法获取到Iterator迭代器，然后使用方法hasNext来判断后面还有没有对象了，如果有就把通过next方法对象给拿出来
public class Run {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("1234567");
        list.add("zjh");
        list.add(1234);
        Iterator it= list.iterator();//通过方法获取迭代器接口实现类的对象
        //迭代器主要有两个方法，一个是hasNext，一个是next
        while(it.hasNext()){
            Object o = it.next();//把对象拿出来
            System.out.println(o.toString());//从这个出来的顺序可见是先进先出，也就是说ArrayList也具有对列的特性
        }
    }
}

1.List：有序，可重复，存入的数据有下标

1.List是一个继承了Collection接口的接口，拥有Collection的所有方法

2.有两个常用的实现类：

1.ArrayList(非线程安全，线程不安全发生在数组扩容时)：

1.底层实现

底层实现就是个数组，适合查询等操作较多的集合

2.构造方法：

分为有参和无参两个版本：

无参的构造方法默认长度为10

有参的构造方法可以指定默认长度

扩容的时候每次增加原长度的1.5倍

2.LinkedList()：

1.底层实现

底层实现就是双向链表，适合插入删除等操作较多的集合

2.构造方法

空构造方法，构造空链表

有参构造方法传入一ArrayList，ArrayList转LinkedList

3.ArrayList和LinkedList拥有相同的方法

remove，contains方法比较都是用equals方法比较来判断是否删除和是否有该元素的，除了上面都有的方法之外还有这几个方法

方法名	性质	形参	返回值	例子	作用
get	非静态	int(下标)	对象	Object o = list.get(i);	获取在容器中下标为i的对象
contains	非静态	对象	boolean	String temp = new String("zjh"); System.out.println("contains:\t"+list.contains(temp));	看看容器中是否有temp对象
remove	非静态	int(下标)		list.remove(3);	按照下标或者对象内容指定删除
remove	非静态	对象		list.remove("emm...");	按照下标或者对象内容指定删除

2.Set：无序，不可重复(重复时只保留最后存入的一次对象（覆盖原来的）)

1.也是个继承Collect的接口

2.三个实现类

1.HashSet:

1.底层实现

底层实现是Map

2.构造方法

默认容量是16，哈希桶是0.75，意思是当容器里元素达到容量百分之七十五之后就开始扩容

无参构造方法形成的是没有元素的集合

有参构造方法可以传递进去一个ArrayList

有参构造方法也可以传入进去一个HashSet的大小，指定的值最好是二的幂次，因为源码在扩容的时候用的是位移扩容

3.HashSet的方法

方法名

性质

形参

返回值

注意

作用

remove

非静态

对象

如果是自己定义的对象记得重写equals方法

这次由于无序，所以没有根据下标删除了

删除一个元素

clear

非静态

删除HashSet里面所有的元素

2.TreeSet（类似于HashSet，但是再进行遍历的时候会进行自动排序）：

TreeSet比较特殊，使用的时候不使用多态，而是多数调用它独有的方法，所以定义引用的时候不用Set而用TreeSet

1.底层实现

底层实现是二叉树

2.TreeSet存储数据

1.TreeSet在存储数据的时候要求数据的类型需要一致，否则会在运行时报异常ClassCastException，

2.在TreeSet存储数据后会自动按照自平衡二叉树的方式来对这些对象进行排序

3.如何对于自定义的数据进行排序

由于TreeSet会自动进行存入数据的排序，调用的是对象的compareTo方法，所以自定义的类需要实现Comparable接口并且重写他的抽象方法：compareTo(),

//compareTo方法在重写的时候由于重写访问权限修饰符不能更小所以就是public
public int compareTo(Object o){
    //逻辑结构:如果对象比传入进来的对象小就返回一个负值，大就正值，等就是0
}

4.自定义类型存入TreeSet

//下列是自定义类型存入TreeSet
public class Run {
    public static void main(String[] args){
        TreeSet ts1 = new TreeSet();
        ts1.add(new Person(14));
        ts1.add(new Person(12));
        ts1.add(new Person(14));
        ts1.add(new Person(15));

        for(Object o : ts1){
            System.out.print(o+"\t");
        }//如果要打印记得要重写equals方法
        System.out.println("\n");
    }
}

public class Person implements Comparable{
    private int age;
    public Person(){}
    public Person(int age){this.age = age;}
    public int getAge(){
        return age;
    }
    public void set(int age){
        this.age = age;
    }
    @Override
    public int compareTo(Object o){//重写方法的时候如果原来的小，就返回负数，如果原来的大就返回正值
        Person p = (Person) o;
        return this.age-p.age;
    }
    @Override
    public String toString(){
        return String.valueOf(age);
    }
}

3.TreeSet的方法

名字	形参	返回值	性质	作用	例子
first		存储的对象	非静态	获取第一个（最小的）对象	System.out.println("自定义存入TreeSet后的第一个元素：\t"+ts1.first());
last		存储的对象	非静态	获取最后一个（最大的）对象	System.out.println("自定义存入TreeSet后的最后一个元素\t:"+ts1.last());

TreeSet ts1 = new TreeSet();
        ts1.add(new Person(14));
        ts1.add(new Person(12));
        ts1.add(new Person(14));
        ts1.add(new Person(15));
        ts1.add(new Person(16));
        ts1.add(new Person(17));
        ts1.add(new Person(19));
        System.out.print("自定义数据存入TreeSet\t" );
        for(Object o : ts1){
            System.out.print(o+"\t");
        }
        System.out.println("\n自定义存入TreeSet后的第一个元素：\t"+ts1.first()+"\t最后一个元素"+ts1.last());

运行结果：

自定义数据存入TreeSet 12 14 15 16 17 19
自定义存入TreeSet后的第一个元素： 12 最后一个元素19

3.LinkedHashSet：的底层实现就是在Map上加了个链表（区别就是有序了，但是这个有序是针对存入取出有序，但是仍然不重复）

3.collection总结代码

public class Person implements Comparable{
    private int age;
    public Person(){}
    public Person(int age){this.age = age;}
    public int getAge(){
        return age;
    }
    public void set(int age){
        this.age = age;
    }
    @Override
    public int compareTo(Object o){//重写方法的时候如果原来的小，就返回负数，如果原来的大就返回正值
        Person p = (Person) o;
        return this.age-p.age;
    }
    @Override
    public String toString(){
        return String.valueOf(age);
    }
}






public class Run {
    public static void main(String[] args) {
        collection();
    }
    public static void collection(){
        Collection list = new ArrayList();
        list.add("1234567");
        list.add("zjh");
        list.add(1234);
        Iterator it= list.iterator();//通过方法获取迭代器接口实现类的对象
        //迭代器主要有两个方法，一个是hasNext，一个是next
        while(it.hasNext()){//看看迭代器是否有下一个
            Object o = it.next();//把对象拿出来。且让迭代器向下指一个元素
            System.out.println(o.toString());//从这个出来的顺序可见是先进先出，也就是说ArrayList也具有对列的特性
        }
        System.out.println("容器长度为：\t"+list.size());
        System.out.println("容器为空：\t"+list.isEmpty());



        //ArrayList部分
        List a = new ArrayList();
        //add的重载默认是尾插
        a.add("adw");
        a.add("adw");//可以体现重复
        a.add("zjh");
        a.add(2,199);//相当于就是插入
        //按常理来讲对容器进行遍历是要通过迭代器的，但是ArrayList有下标，所以此时选择的是直接通过下标来进行遍历
        //此时就有了get方法来获取对象，get的形参时对象的下标
        System.out.print("容器内现有元素:\t");
        for(int i = 0;i<a.size();i++){
            Object o = a.get(i);
            System.out.print(o+"\t");
        }
        //contains方法：比较容器当中是否有某个对象
        //判断是否有这个对象的时候调用的这个对象的equals方法
        //在添加对象进入容器的时候要把这个对象的equals方法重写
        String temp = new String("zjh");
        System.out.println("\ncontains:\t"+a.contains(temp));//虽然s指向的是字符串对象，字符串对象里面含有字符串的地址，也就是说s指向的地址和容器当中所保存的字符串地址是不同的，但是contains在比较的时候调用了对象的equals方法，所以返回值是true
        //remove方法
        System.out.println("删除前容器长度"+a.size());
        a.remove(2);//删除下标为2的元素,删除某个元素后其余元素会填补回来
        a.remove("adw");//按照对象删除的时候只删除一遍
        System.out.println("删除后容器长度"+a.size());
        System.out.print("容器内剩余的元素:");
        for(int i = 0;i<a.size();i++){
            Object o = a.get(i);
            System.out.print(o+"\t");
        }
        System.out.println("\n");



        //LinkedList部分
        List list1 = new LinkedList(a);
        Iterator itr = list1.iterator();
        System.out.print("list1容器里的元素为\t");
        while(itr.hasNext()){
            Object o = itr.next();
            System.out.print(o+"\t");
        }
        list1.add("wada");
        list1.remove("adw");
        System.out.print("\n删除“adw”，插入“wada之后还剩”"+list1.size()+"个元素，分别是\t");
        for(int i = 0;i<list1.size();i++){
            System.out.print(list1.get(i)+"\t");
        }
        //也可以直接使用增强型for循环
//        for(Object o :list1){
//            System.out.println(o);
//        }
        System.out.println("\n");



        //Set
        //HashSet部分
        Set s=new HashSet();
        s.add("牛马");
        s.add("sad");
        s.add(new String("sad"));//此处说明了和contains一样，判断重复与否是根据equals方法的
        s.add("asd");
        s.add("asd");
        System.out.println("HashSet容器长度为："+s.size()+"体现了Set的不可重复性，如果重复后面的会覆盖前者的数据");
        System.out.print("s中的元素有：\t");//从打印结果来看就可以知道这个时候是无序的取出
        for (Object o :s) {
            System.out.print(o+"\t");
        }
        s.clear();
        System.out.println("\nclear之后的s的长度：\t"+s.size());




        //TreeSet部分,存储的数据，数据类型必须保持一致
        TreeSet ts = new TreeSet();//会按照自平衡二叉树的方式对于给定的数据进行排序
        ts.add(22);
        ts.add(33);
        ts.add(453);
        ts.add(3);
        ts.add(34);
        ts.add(231);
        System.out.print("ts里面的元素为：\t");
        for(Object o : ts){
            System.out.print(o+"\t");
        }
        System.out.println("\n");

        //自定义类型的比较需要在自定义的类当中实现Comparable接口并且重写compareTo方法
        TreeSet ts1 = new TreeSet();
        ts1.add(new Person(14));
        ts1.add(new Person(12));
        ts1.add(new Person(14));
        ts1.add(new Person(15));
        ts1.add(new Person(16));
        ts1.add(new Person(17));
        ts1.add(new Person(19));
        System.out.print("自定义数据存入TreeSet\t" );
        for(Object o : ts1){
            System.out.print(o+"\t");
        }
        System.out.println("\n自定义存入TreeSet后的第一个元素：\t"+ts1.first()+"\t最后一个元素"+ts1.last());
    }
}

2.Map，存放键值对的类型

1.底层实现

底层实现是数组

通过键值对的形式来存储，根据key值来计算哈希地址，然后把value对象的地址存入计算出来的哈希地址如果遇到了冲突会按照相应的算法进行寻找

2.HashMap

方法

名字	性质	形参	返回值	作用	注意
put	非静态	键值对		存入数据	前key后value，存入的是地址，key一样会覆盖value
get	非静态	value值	对象	取出key值对应的对象
keySet	非静态		Set对象	取出来所有的key值形成一个Set集合
remove	非静态	key		删除某个元素