Java集合一(List和Set)

概念

目前存储数据的方式有哪些

数组；

基于数组模拟的容器类；

基于链表结构的容器类；

在Java中已经设计好了一些类和接口，和我们之前模拟的容器类功能一样。像这样的类和接口，在Java中已经写好了，我们叫做集合

List和Set的区别

List和Set的区别

相同点：都继承了Collection接口，都是Java中的集合，都可以存放任意类型任意多个元素

不同点：

List：有序可重复

​ ArrayList和LinkedList

Set：无序不可重复

​ HashSet：去重是通过hashCode()和equals()共同决定

​ TreeSet：去重是通过自然排序(实现Comparable接口)或者定制排序(创建对象时传入的比较器)来实现

List集合

ArrryaList(基于数组)

底层是由数组实现

ArrayList基于数组的容器类实现

调用容器类方法增删改查数据

Demo

package com.ifueen.classtest._01ArrayList;
import java.util.ArrayList;
import java.util.Iterator;

import javafx.print.Collation;

public class _01ArrayList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList list = new ArrayList();		//实例化ArrayList对象
		list.add(15);					//给集合添加元素
		list.add(0,"我今年");		//add(int index, E element):在此列表中指定的位置插入指定的元素
		list.clear();						//clear():从此列表中移除所有元素
		list.add("你离开了南京");
		list.add("从此没人陪我说话");
		System.out.println(list);		//打印集合中的元素
		ArrayList list1 = new ArrayList();
		list1.add("我不想说");
		list1.add(34);
		list1.add(1,"我今年");
		list1.add("了");
		System.out.println(list1);
		Iterator iterator = list.iterator();
		while(iterator.hasNext()){						//hasNext()方法作用：如果仍有元素可以迭代，则返回 true
			System.out.println(iterator.next());		//next()方法作用：返回迭代的下一个元素,用Object类型的变量接收
		}
	}

}

LinkedList(基于链表)

基于链表结构的容器类实现

LinkedList 属于java.util包下面，也实现Iterable接口，说明可以使用迭代器遍历；

Demo

package com.ifueen.classtest._02LinkedList;

import java.util.Iterator;
import java.util.LinkedList;

public class _02LinkedList {
	/*
	 * LinkList集合：底层由链表实现
	 * */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		LinkedList list = new LinkedList();
		list.add(15);					//给集合添加元素
		list.add(0,"我今年");		//add():在此列表中指定的位置插入指定的元素
		list.clear();						//clear():从此列表中移除所有元素
		list.add("你离开了南京");
		list.add("从此没人陪我说话");
		
		//for循环来遍历
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));		//get方法作用：返回此列表中指定位置处的元素
		}
		
		//foreach来遍历
		for (Object object : list) {
			System.out.println(object);
		}
		
		//用迭代器来遍历
		Iterator iterator = list.iterator();		//新建迭代器
		while (iterator.hasNext()) {			//利用迭代器进行遍历
			Object object = (Object) iterator.next();	//返回迭代的下一个元素,用Object类型的变量接收
			System.out.println(object);		//输出元素
		}
	}

}

面试题：ArrayList和LinkedList区别

两者都是实现List接口，都可以存放任意多个任意类型的数据

ArrayList底层是由数组来实现，在数据量多的时候，查询起来较快，但是新增的时候需要不停创建新的数组，速度就会变慢

LinkList底层是由链表实现，在数据量大的时候，需要去到每一个节点去挨个查找，所以查询起来的速度比较慢，但是在新增的时候就比较快

Set集合

HashSet

存储任意多个类型不同的元素，但是是无序(添加顺序和输出顺序不一致)，且不能重复，如果有重复元素，会自动去重

Demo

package com.ifueen.classtest._03HashSet;

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

public class _03HashSet {
	/*
	 * HashSet：存储任意多个类型不同的元素，但是是无序(添加顺序和输出顺序不一致)
	 * 					且不能重复，如果有重复元素，会自动去重
	 * */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashSet hst = new HashSet();		//实例化HashSet对象
		hst.add("你离开了南京");					//往集合里面添加元素
		hst.add("从此没有人和我说话");		
				
		System.out.println(hst);
		HashSet hst1 = new HashSet();		//实例化HashSet对象
		hst1.add("A");
		hst1.add("C");
		hst1.add("B");
		hst1.add("E");
		hst1.add("D");
		//System.out.println(hst1);  //输出[A, B, C, D, E]，不会按照添加的顺序输出
		hst1.clear();  	//清除元素
		
		hst1.add("A");
		hst1.add("A");
		hst1.add("B");
		System.out.println(hst1);  	//输出[A, B]，自动去重
		
		_03Test test1 = new _03Test("我想");
		_03Test test2 = new _03Test("我想");
		hst1.add(test1);
		hst1.add(test2);
		System.out.println(hst1);		//此时只会打印一个我想，实现了去重功能
		}
		
	}

}

TreeSet

支持存储任意多个类型不同的元素，无序(添加顺序和输出顺序不一致)不可重复，但是同时只能放同一种类型，想要添加自定义类型就需要在自定义类里面实现自由排序(自然排序就是实现Comparable接口)

定制排序和自然排序的区别：

自然排序：所有排序都按照统一的规则

定制排序：按照自定义的规则来进行排序

Demo

package com.ifueen.classtest._04TreeSet;

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

public class _04TreeSet {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeSet tst = new TreeSet();  //实例化TreeSet对象
		tst.add("我们不能失去信仰");		//添加元素
		tst.add("查拉图斯特拉如是说");
		System.out.println(tst);
		
		TreeSet tst1 = new TreeSet(); 
		tst1.add("木卫三");
		tst1.add("远航");
		//tst1.add(46);
		tst1.add("远航");
		System.out.println(tst1);  //报错：java.lang.String cannot be cast to java.lang.Integer同时只能存放同一类型
		
		
		_04Person p1 = new _04Person("开心");
		_04Person p2 = new _04Person("开心");
		_04Test test = new _04Test();
		TreeSet tst2 = new TreeSet(test); //实例化Tree对象并传入test类对象
		tst2.add(p1);
		tst2.add(p2);
		System.out.println(tst2);		//输出一个开心，说明我们自定义去重成功
		
		//遍历方式
		//forearch
		for (Object object : tst2) {
			System.out.println(object);
		}
		//利用迭代器遍历
		Iterator iterator = tst2.iterator();
		while (iterator.hasNext()) {
			Object object = (Object) iterator.next();	//返回迭代的下一个元素,用Object类型的变量接收
			System.out.println(object);
		}
		
	}

}