java集合框架学习笔记

思维导图

一、什么是集合

存放在java.util.*。是一个存放对象的容器。

• 存放的是对象的引用，不是对象本身
• 长度不固定
• 只能存放对象

二、collection接口

collection的使用

• 增加元素 add();
• 判断是否包含某个元素 contains();
• 删除某个元素 remove();
• 遍历元素（iterator迭代器）

package com.zheng.demo1;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class MyCollection {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        //增加元素
        c.add("足球");
        c.add("篮球球");
        c.add("乒乓球");
        //集合大小
        System.out.println("当前集合大小：" + c.size());
        //判断是否包含某个元素
        System.out.println(c.contains("足球"));
        //删除元素
        c.remove("足球");
        System.out.println("删除一个元素之后大小：" + c.size());
        System.out.println("===============");
        
        //打印,增强for循环
        for (Object obj : c) {
            System.out.println("增强for循环取值："+obj);
        }
        System.out.println("==============");

        //迭代器形式
        Iterator it = c.iterator();
        while (it.hasNext()){//判断有无下一个元素
            Object obj=it.next();//取值
            System.out.println("iterator取值："+obj);

        }


    }
}

Iterator：迭代器

• hasNext(); 查看是否有下一个元素。有为true，无为false
• next(); 取出下一个元素的值
• remove(); 删除当前元素

在JAVA中，所有的对象都有toString方法；方便打印

通过添加一个对象到collection集合中

实体类

package com.zheng.demo1;

public class Student {
    private int id;
    private String name;
    private String address;

    public Student() {

    }

    public Student(int id, String name, String address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

加入到集合

package com.zheng.demo1;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class MyCollection1 {
    public static void main(String[] args) {
        //创建容器
        Collection<Student> students = new ArrayList<Student>();

        //创建对象
        Student student1 = new Student(1, "小明", "北京");
        Student student2 = new Student(2, "小红", "河南");
        Student student3 = new Student(3, "小黑", "深圳");
        Student student4 = new Student(4, "小蓝", "上海");

        //添加对象到容器中
        students.add(student1);
        students.add(student2);
        students.add(student3);
        students.add(student4);

        //查看
        System.out.println(students.toString());

        System.out.println("=========增强for循环输出=========");
        //增强for循环输出
        for (Student student : students) {
            System.out.println(student.toString());

        }

        System.out.println("=========迭代器输出=========");
        //迭代器输出
        Iterator<Student> iterator = students.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    }
}

三、List集合

特点

• 有序，打印输出的顺序和添加时的顺序一致（不会帮你自动排序）
• 有下标，可以通过下标的形式访问对象
• 元素可以重复

方法

• void add(int index,Object o) //在index位置插入元素
• boolean addAll(int index,Collection c) //将一个集合中的元素添加到次集合中的index位置
• Object get(int index) //返回集合中指定位置的元素
• List subList(int fromIndex,int toIndex) //返回二者之间的元素

package com.zheng.demo1;

import java.util.ArrayList;
import java.util.ListIterator;

public class MyList2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(2);
        list.add(3);
        list.add(1);
        list.add(5);
        list.add(2);
        list.add(4);

        System.out.println("通过下标访问：" + list.get(0));

        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
    }
}

listIterator：迭代器

• hasNext(); 查看是否有下一个元素。有为true，无为false
• next(); 取出下一个元素的值
• hasPrevious();查看前一个元素是
• previous();取出前一个元素
• remove(); 删除当前元素

package com.zheng.demo1;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class MyList {
    public static void main(String[] args) {
        //创建一个list集合容器
        List list = new ArrayList();

        //添加数据
        list.add("1-小红");
        list.add("2-小黑");
        list.add("3-小青");
        list.add("4-小紫");

        System.out.println("当前集合大小" + list.size());

        //一般的遍历
        System.out.println("=========一般的遍历=======");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));

        }
        System.out.println("=========增强for循环遍历=======");
        //增强for循环遍历
        for (Object o : list) {
            System.out.println(o);

        }

        System.out.println("=========一般的迭代器遍历=======");
        //一般的迭代器遍历
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.println("=========list迭代器从前到后遍历=======");
        //list特有的
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            String str = (String) listIterator.next();
            System.out.println(str);
        }

        System.out.println("=========list迭代器从后到前遍历=======");
        while (listIterator.hasPrevious()) {
            Object obj = listIterator.previous();
            System.out.println(obj);
        }

    }
}

List实现类

1、ArrayList【重点】

• 数据结构实现，查询快（数组是连续的存储地址）。增删慢（每增加或者删除都要移动大量的数据。末尾快一点）
• jdk1.2版本。运行效率高，线程不安全

2、Vector:

• 数组结构，查询快，增删慢
• jdk1.0版本，运行效率低，线程安全

3、LinkedList

• 链表结构实现，增删快（不连续的存储空间，只需要改变节点之间的指向）查询慢
• 
  

package com.zheng.demo1;

import java.util.LinkedList;
import java.util.ListIterator;

public class MyLinkList {

    public void print(LinkedList<Student> students) {
        //迭代器遍历
        System.out.println("======迭代器遍历======");
        ListIterator<Student> studentListIterator = students.listIterator();
        while (studentListIterator.hasNext()) {
            Student student = studentListIterator.next();
            System.out.println(student);
        }
    }

    public static void main(String[] args) {
        MyLinkList myLinkList = new MyLinkList();

        //1、创建一个容器
        LinkedList<Student> students = new LinkedList<>();

        //2、创建对象
        Student student1 = new Student(1, "小黑", "周口");
        Student student2 = new Student(2, "小名", "沈丘");
        Student student3 = new Student(3, "小郑", "范营乡");
        Student student4 = new Student(4, "小芳", "666");

        //3、将对象加入集合
        students.add(student1);
        students.add(student2);
        students.add(student3);
        students.add(student4);

        //查看
        System.out.println(students.toString());
        
        //调用迭代器遍历
        myLinkList.print(students);

        //删除
        System.out.println("=====删除某个元素=====");
        students.remove(1);
        myLinkList.print(students);


    }
}

四、泛型

jdk1.5中引入的新特性。本质是参数化类型，把类型当做参数传递

• 泛型接口、泛型方法、泛型类
• <T,…> T为占位符，表示一种引用类型
• 优点：（1）、提高代码的复用。（2）、防止类型转换异常，提高代码的安全性

1、泛型类

• 泛型变量
• 泛型作为传递的参数
• 泛型作为方法的返回值
• 
  

注意：

• 泛型只能使用引用类型
• 不同泛型类型对象之间不能相互赋值

package com.zheng.demo2;

//泛型类
public class MyGeneric<T> {

    T t;//1、泛型变量

    //2、泛型作为传递的参数
    public void show(T t) {
        System.out.println(t);
    }

    //3、泛型作为方法的返回值
    public T getT() {
        return t;
    }
}

package com.zheng.demo2;

public class TestMyGeneric {

    public static void main(String[] args) {
        //使用泛型类创建对象
        MyGeneric<String> sm = new MyGeneric<>();
        sm.t = "你好";
        sm.show("呦呦呦");
        System.out.println(sm.getT());

        System.out.println("=============");

        MyGeneric<Integer> im = new MyGeneric<>();
        im.t = 999;
        im.show(666);
        System.out.println(im.getT());


    }
}

2、泛型接口

package com.zheng.demo2;

public interface MyInterface<T> {
    T show(T t);
}

实现类

package com.zheng.demo2;

public class MyInterfaceImpl1 implements MyInterface<Integer>{

    @Override
    public Integer show(Integer integer) {
        return integer;
    }

    public static void main(String[] args) {
        MyInterfaceImpl1 impl1 = new MyInterfaceImpl1();
        System.out.println(impl1.show(999));
    }


}

2、

package com.zheng.demo2;

public class MyInterfacetImpl implements MyInterface<String>{
    public String show(String s) {
        return s;
    }

    public static void main(String[] args) {
        MyInterface omf = new MyInterfacetImpl();
        System.out.println(omf.show("hhhhhh"));
    }
}

3、

package com.zheng.demo2;

public class MyInterfaceImpl2<T> implements MyInterface<T> {

    @Override
    public T show(T t) {
        return t;
    }

    public static void main(String[] args) {
        MyInterfaceImpl2<String> impl2 = new MyInterfaceImpl2<>();
        System.out.println(impl2.show("daoajao"));
        System.out.println("============");
        MyInterfaceImpl2<Double> impl21 = new MyInterfaceImpl2<>();
        System.out.println(impl21.show(520.1313));
    }
}

3、泛型方法

package com.zheng.demo2;

public class MyGenericMethod {

    //泛型方法
    public <T> T show(T t) {
        System.out.println("泛型方法" + t);
        return t;
    }


    public static void main(String[] args) {
        System.out.println(new MyGenericMethod().show(5));
        System.out.println("=============");
        System.out.println(new MyGenericMethod().show("哈哈哈哈"));
    }
}

四、set集合

无序、无下标、元素不可重复

1、hashSet【重点】

• 数组+链表+红黑树
• 基于hashcode计算元素存储位置
• 当哈希吗一样的时候，调用equals，如果为true,拒接存入

package com.zheng.demo3;

import java.util.HashSet;
import java.util.Iterator;

public class MySet {
    public static void main(String[] args) {
        
        //创建集合框架
        HashSet<String> set = new HashSet<>();

        //添加数据
        set.add("1-小红");
        set.add("2-小明");
        set.add("3-小白");
        set.add("4-小黑");
        set.add("5-小红");
        set.add("1-小红");

        //迭代器迭代集合元素 遍历
        Iterator<String> iterator = set.iterator();
      
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    }
}

实体类

package com.zheng.demo3;

public class School {
    private int id;
    private String name;

    public School() {

    }

    public School(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "School{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

package com.zheng.demo3;

import java.util.HashSet;
import java.util.Iterator;

public class TestSet {
    public static void main(String[] args) {

        //1、创建集合容器
        HashSet<School> schools = new HashSet<>();

        //创建对象
        School school1 = new School(1, "清华大学");
        School school2 = new School(2, "北京大学");
        School school3 = new School(3, "浙江大学");

        //3、放入集合

        schools.add(school1);
        schools.add(school2);
        schools.add(school3);
        schools.add(new School(2,"北京大学"));

        //4、遍历

        Iterator<School> iterator = schools.iterator();
        while (iterator.hasNext()){
            School school=iterator.next();
            System.out.println(school);
        }


    }
}

2、TreeSet

• 存储结构：红黑树
• 要实现comparable接口，重写里边的方法，返回0代表元素重复
• 元素不重复
• 元素自动排序

package com.zheng.demo3;

import java.util.Iterator;
import java.util.TreeSet;

public class MyTree {
    public static void main(String[] args) {

        //1、创建一个集合
        TreeSet treeSet = new TreeSet();

        //2、加入元素
        treeSet.add(1);
        treeSet.add(3);
        treeSet.add(2);
        treeSet.add(4);
        treeSet.add(3);


        //3、迭代遍历
        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()) {
            int i = (int) iterator.next();
            System.out.println(i);
        }


    }
}

TreeSet案例：排列字符串的顺序

package com.zheng.demo3;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class MyTreeSet {
    public static void main(String[] args) {
        //匿名内部类
        TreeSet<String> set = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int n1 = o1.length() - o2.length();
                int n2 = o1.compareTo(o2);
                return n1 == 0 ? n2 : n1;
            }

        });


        set.add("he");
        set.add("hhhhh");
        set.add("jdjdjkdkk");
        set.add("djdj");


        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

comparator：定制比较器

五、Map集合【重要】

特点：

• 用于存储任意键值对（k-v）
• key不能重复，唯一。无序、无下标
• value可以重复。无序、无下标

1、hashMap

• 存储结构：哈希表（数组+链表+红黑树）
  方法：
• put(k,v);存入
• get(k);取值
• containsKey();判断是否包含key
• containsValue();判断 是否包含value
• entrySet();返回映射关系中包含的映射视图
• keySet();返回映射关系中包含的键的映射视图

package com.zheng.demo4;

import javax.lang.model.element.NestingKind;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MyMap {
    public static void main(String[] args) {

        //1、创建集合
        Map<String, String> map = new HashMap<>();

        //2、塞入值
        map.put("A", "我是A");
        map.put("B", "我是B");
        map.put("C", "我是C");
        map.put("D", "我是D");

        //判断
        System.out.println(map.containsKey("A"));
        System.out.println(map.containsValue("我是C"));

        System.out.println("map集合大小：" + map.size());
        System.out.println("打印：" + map.toString());

        //遍历1、使用keyset
        System.out.println("=======使用keyset=======");
        Set<String> set = map.keySet();
        for (String s : set) {
            System.out.println(s + "=======" + map.get(s));

        }

        System.out.println("=======使用entryset=======");

        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey() + "========" + entry.getValue());

        }

        //简化
        System.out.println("+===简化====+");
        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "========" + entry.getValue());

        }


    }
}

jdk1.8后当链表长度大于8，转化为红黑树存储

jdk1.8后，当链表长度小于6,转化为链表存储

map集合的实现类

• HashMap
  jdk1.2版本，线程不安全，运行快；允许null为key或者value
• Hashtable
  jdk1.0版本，线程安全，运行慢，不允许null为key或者value
• properties
  Hashtable的子类，使用String作为key或者value.通常用于配置文件的读取

六、Collections工具类

package com.zheng.demo5;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyCollection {
public static void main(String[] args) {
List arrayList = new ArrayList();
arrayList.add(4);
arrayList.add(1);
arrayList.add(5);
arrayList.add(3);
arrayList.add(6);
arrayList.add(2);

    System.out.println(arrayList.toString());
    System.out.println("调用排序工具类");
    //调用工具类排序
    Collections.sort(arrayList);
    System.out.println(arrayList.toString());

}

}

总结

集合的概念

• 对象的容器，和数组相似，定义了多个对象进行操作的常用方法

List集合

• 有序、有下标、元素可以重复（ArrayList,LinkedList,Vector）

set集合：

• 无序、无下标、元素不可重复（HashSet,TreeSet）

Map集合

• 存储一对数据，无序，无下标，键不可重复，值可以重复（HashMap,HashTable,TreeMap）

Collections:

• 集合工具类，定义了除存取以外的集合常用方法