JavaSE进阶第十五天——集合篇

代码瞬间CV攻城狮

已于 2022-03-29 13:02:07 修改

阅读量115

点赞数

分类专栏：笔记唠嗑 java 文章标签： java

于 2022-03-18 20:43:55 首次发布

本文链接：https://blog.csdn.net/For_Future_Kun/article/details/123560106

版权

笔记同时被 3 个专栏收录

23 篇文章 0 订阅

订阅专栏

java

23 篇文章 0 订阅

订阅专栏

唠嗑

15 篇文章 0 订阅

订阅专栏

文章目录

集合

集合

集合的概念：集合实际上就是一个容器，集合中存储的都是对象。对象可以是不同类型的数据。

集合的特点：

集合中保存的数据都是对象
集合的大小是动态可变的
集合的底层数据结构很多：栈、哈希表、数组、列表、树等等

集合的分类：

单个方式存储元素（Collection）：一次只能往集合中存单值。
键值对的方式存储元素（Map）：一次往集合中存key(键)和value(值)

集合详细结构图：
在这里插入图片描述

Iterator迭代器

迭代器的作用就是用于遍历集合（Collection）。
iterator.hasNext()：判断集合中是否还有下一个数据。
iterator.next()：按顺序取出集合中的一个数据。

collection集合

collection集合中我们主要学习List集合中的ArrayList和LinkedList以及Set集合。Vector和Stack基本不用作为了解即可。
collection集合的常用方法(熟记)：

add()
remove()
isEmpty()
contains()
size()
clear()
iterator()
toArray()

List集合

List集合的特点：有序可重复。
List集合常用方法：

get(int index)
set(int index,Object obj)
remove(int index)
add(Object obj)

ArrayList

ArrayList集合底层使用的是数组结构。
ArrayList集合特点：查询效率高。插入删除效率较低。

ArrayList的声明和使用方法：

class Test{
	public static void main(String[] args){
		List list = new ArrayList();//我们最好还是使用多态机制
		Student stu1 = new Student("张三",18);
		Student stu2 = new Student("李四",23);
		Student stu3 = new Student("王五",16);		
		
		//往集合中添加数据
		list.add(stu1);
		list.add(stu2);
		list.add(stu3);

		//设置集合中的元素
		list.set(1,stu2);
		
		//删除集合中元素
		list.remove(s3);

		//集合排序
		Collections.sort(list);
		
		//迭代集合
		Iterator iterator = list.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}
}
//学生类 实现Comparable接口
class Student implements Comparable{
    private String name;
    private int age;
    
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    @Override
    public int compareTo(Object o) {
        Student s = (Student) o;
        return this.age-s.getAge();
    }
}

LinkedList集合

LinkedList集合底层使用的是双向链表结构。链表之间通过节点(node)连接。
LinkedList集合的特点：查询效率低，插入删除效率高。
LinkedList的使用和声明和ArrayList基本一样，这里就不赘述了。
单项链表结构图：
在这里插入图片描述 双向链表结构图：

Vector集合和Stack

Vector集合和Stack目前基本不用了，做了解即可。
Vector:Vector 已经不建议使用，Vector 中的方法都是同步的，效率慢，已经被 ArrayList取代。
Stack 是继承 Vector 实现了一个栈，栈结构是后进先出，目前已经被 LinkedList 取代。

Set集合

HashSet集合

HashSet集合底层使用的是哈希表结构。
HashSet集合的特点：无序不可重复。
HashSet的使用和声明：

class HashSetTest{
	public static void main(String[] args){
		//创建set集合
		Set set = new HashSet();
		//创建学生对象
		Student stu1 = new Student("张三",18);
	    Student stu2 = new Student("李四",21);
	    Student stu3 = new Student("王五",21);
	    Student stu4 = new Student("赵六",28);
		//添加到集合
		set.add(stu1);
		set.add(stu2);
		set.add(stu3);
		set.add(stu4);
		//添加重复元素
		set.add(stu1);

		//创建迭代器
		Iterator iterator = set.iterator();
		//迭代集合
	    while(iterator.hasNext()){
	       System.out.println(iterator.next());
	    }
	}
}
//学生类
class Student  {
    private String name;
    private int age;
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

查看输出结果
在这里插入图片描述

明显输出结果和输入的顺序不同，可以确定HashSet集合是无序的，且加入重复数据虽然没有报错，但是输出的时候任然只有4个。也可以看出HashSet集合是无法加入重复数据的，或者说数据被覆盖了。

那么实际上HashSet到底是怎么做到无重复数据的呢？
首先我们可以先去查看每个对象的hashCode是否相同，调用hashCode()方法查看,如果hashCode不相同，则hashset认为是不同的元素，分别加入集合;如果hashcode相同，则hashset会去查看每个对象的内容是否相同，调用equals()方法，如果内容不相同，则hashset认为它们是不同的对象，分别
加入集合;如果内容相同，则hashset认为是相同的对象，则进行消重处理。

假设我们在上面的代码中新建一个学生对象，学生对象中的数据和其中一个对象的数据相同，那么会发生什么？：

class HashSetTest{
	public static void main(String[] args){
		//创建set集合
		Set set = new HashSet();
		//创建学生对象
		Student stu1 = new Student("张三",18);
	    Student stu2 = new Student("李四",21);
	    Student stu3 = new Student("王五",23);
	    Student stu4 = new Student("赵六",28);
	    Student stu5 = new Student("赵六",28);
		//添加到集合
		set.add(stu1);
		set.add(stu2);
		set.add(stu3);
		set.add(stu4);
		//添加重复元素
		set.add(stu1);
		//删除元素
		set.remove(stu5);
		
		//创建迭代器
		Iterator iterator = set.iterator();
		//迭代集合
	    while(iterator.hasNext()){
	       System.out.println(iterator.next());
	    }
	}
}

结果：
在这里插入图片描述这是为什么呢？明明删除的是stu5啊。别忘了HashSet是怎么消重的。如果hashcode相同，则hashset会去查看每个对象的内容是否相同，调用equals()方法，如果内容不相同，则hashset认为它们是不同的对象，分别
加入集合;如果内容相同，则hashset认为是相同的对象。所以，在这里stu4和stu5会被认为是同一个对象，所以删除stu5实际上就是删除stu4。

TreeSet集合

TreeSet集合是Set集合下的SortedSet下的集合。也叫做排序集合。默认自然排序升序。
排序集合，顾名思义，放入的对象会默认升序排序。前提是放入对象的类需要实现Comparable接口或者Comparactor接口。

例子：

public class TreeSetTest {
	public static void main(String[] args) {
		//创建Student对象
		Student stu1 = new Student("张三",18);
        Student stu2 = new Student("李四",21);
        Student stu3 = new Student("王五",21);
        Student stu4 = new Student("赵六",28);
		//创建TreeSet
		Set set = new TreeSet();
		//添加数据到集合
		set.add(stu1 );
		set.add(stu2);
		set.add(stu3);
		//加入重复数据
		set.add(stu2);
		 //创建迭代器
        Iterator iterator = set.iterator();
        //迭代集合
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
	} 
}

//学生类 实现Comparable接口
class Student implements Comparable{
    private String name;
    private int age;
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Object o) {
        Student s = (Student) o;
        return this.age-s.getAge();
    }
}

TreeSet消除重复和排序使用都是同一种方式，去实现Comparable接口中的compareTo().

Map集合

Map集合中我们重点学习HashMap集合。
Map集合常用方法：

put(key,value)
keySet()
clear()
containsKey()
entrySet()
get(key)
isEmpty()
remove()
size()

Map中遍历的方法：

遍历键: keySet()
遍历值: values()
遍历键和值: entrySet()

HashMap集合

HashMap集合底层结构：往集合中添加元素时，如果元素的数量在8个以内，那么使用的是链表结构,多于8个，就树化，采用的是二叉树(红黑树)。

HashMap集合特点：无序不可重复。

HashMap的使用和声明：


public class Test{
	public static void main(String[] args) {
		Map map = new HashMap();
		map.put("001", "张三");
		map.put("002", "李四");
		map.put("003", "王五");
		//采用 entrySet 遍历 Map
		Set entrySet = map.entrySet();
		for (Iterator iter=entrySet.iterator(); iter.hasNext();) {
		Map.Entry entry = (Map.Entry)iter.next();
		
		System.out.println(entry.getKey() + ", " + entry.getValue());
		}
		System.out.println("");
		//取得 map 中指定的 key
		Object v = map.get("1003");
		System.out.println("1003==" + v);
		System.out.println("");
		//如果存在相同的条目，会采用此条目替换
		//但 map 中始终保持的是不重复的数据
		//主要依靠 key 判断是否重复，和 value 没有任何关系
		map.put("1003", "赵柳");
		//采用 keySet 和 get 取得 map 中的所有数据
		for (Iterator iter=map.keySet().iterator(); iter.hasNext();) {
		String k = (String)iter.next();
		System.out.println(k + ", " + map.get(k));
		} 
	} 
}

HashTable集合

和HashMap一样，使用哈希算法。语法结构是一样的。

HashMap和Hashtable的区别：

集合	特征	是否为空
HashMap	轻量级、速度快、线程不安全	键、值都能为null
HashTable	重量级、速度慢、线程安全	键、值都不能为null

SortedMap集合

TreeMap 可以对 Map 中的 key 进行排序。key 采用的是自定类那么需要实现Comaprable 或 Comparator 接口完成排序。实际上TreeSet底层就调用了TreeMap。
TreeMap集合特点：有序不可重复。

TreeMap的使用和声明：

public class TreeMapTest01 {
	public static void main(String[] args) {
			Map map = new TreeMap();
			map.put("3", "王五");
			map.put("1", "张三");
			map.put("2", "李四");
			for (Iterator iter=map.entrySet().iterator(); iter.hasNext();) {
			Map.Entry entry = (Map.Entry)iter.next();
			System.out.println(entry.getKey() + ", " + entry.getValue());
		}
	}
}