List，Set, Map三大集合 笔记

写给自己留个记录，同时也希望能帮助到你们~

技术交流群：167692269

----------------------

目录：

1.三大集合及各自特点

2.集合的好处及关系图

3.Collection接口中常用的方法

4.用于遍历的Iterator接口的用法

5.Set集合 实现不重复的原因 及举例

6.List集合中特有的方法

7.LinkedList集合和ArrayList集合的区别

8.Collections集合

9.Map集合常用方法及两种遍历方式

10.集合的排序方式及自定义类排序的两种方式

------------------------------

1.集合主要分为三种：Set，List，Map。

       特点：

        Set：无序不可重复

        List：有序可重复，可以根据下标取值

        Map：存放的是一个键值对，值可重复，键不可以重复

2.

 集合是一种容器，可以存储若干个性质相同或相近的数据，但集合要求不能存储基本类型数据，只能存储引用类型数据
 集合相比于数组而言，最大的好处在于，其长度不固定，随时可变。

 集合分为两大阵营：Collection阵营和Map阵营

 List和Set同属于Collection，是Collection接口的两个子接口

Set的实现类：HashSet、TreeSet
List的实现类：ArrayList、LinkedList
Map的实现类：HashMap、TreeMap

具体关系，如下图：

3.

Collection接口中常用的方法：

（因为List，Set接口继承了Collection接口，所以他们的实现类ArrayList，LinkedList, HashSet, TreeSet中也会有这些方法）

int size();    //获取集合当前的长度，返回值为int类型

boolean isEmpty();    //判断当前集合是否为空，返回值是boolean类型

void clear();    //将集合当前的元素清空

boolean add(Object element)；    //向集合里面添加一个元素

boolean remove(Object element)；    //移出当前元素  

boolean contains(Object element)；    //判断集合是否包含某元素

Object[ ] toArray();    //将集合转换为一个Object类型的数组

Iterator iterator();    //返回一个Iterator的迭代器

4.

Iterator接口

作用：遍历容器中的元素

方法：

        boolean hasNext（）；    //判断集合中是否含有元素

        Object next（）；         //接收集合中当前读到的元素

        void remove（）；        //移出集合中当前读到的元素

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

public class TestIterator {
	public static void main(String[] args) {
			Collection c=new HashSet();
			c.add(true);
			c.add(1);
			c.add("haha");
							
			//所有实现了Collection接口的类均具备一个iterator方法
			//此方法会生成一个Iterator接口实现类类型的对象，用于遍历集合
			Iterator it=c.iterator();
			//Iterator提供的hasNext（）用于判断集合中是否还有数据
			while(it.hasNext()){
				//当集合中存在待遍历的数据时，利用next（），
				//光标会向后移动一位，将数据暴露，因此next（）方法返回的数据就是我们要遍历的每一个数据
				//while循环不断执行，每当hasNext（）放回true时，就利用next（）获取一个数据，
				//hasNext（）返回false为止
				Object obj=it.next();
				System.out.println(obj);
				//移出之后，集合里就没有数据啦
				it.remove();
				
			}
			//it.remove();
			//集合已经没有数据了，如果再移除，就会出错。
			
			System.out.println("-------------");
			it=c.iterator();
			while(it.hasNext()){
				System.out.println(it.next());
			}
			
			
			

	}

}

5.

Set集合

Set集合之所以能实现无序不重复，是因为Set集合调用add（）方法时，会自动调用hashCode（）方法和equales（）方法。

hashCode（）判断地址。equals（）判断值。

举例：

（1.）创建一个SoftwareEngineer类，用于向Set集合中添加元素

public class SoftwareEngineer {	
	private int age;
	private int no;
	public SoftwareEngineer(int age ,int no){
		this.age=age;
		this.no=no;
	}

	@Override     
	public int hashCode() {        //重写hashCode方法
		System.out.println("hashCode被调用");
		//age 0 no 12121
		//age 1 no 0
		return this.age+no+1;
	}
	@Override
	public boolean equals(Object obj) {        //重写equals方法
		System.out.println("equlals被调用");
		if(obj instanceof SoftwareEngineer){
			SoftwareEngineer se=(SoftwareEngineer)obj;
			return this.age==se.age&&this.no==se.no;
		}	
		return false;
	}
}

（2.）创建一个HashSet集合用于测试

import java.util.HashSet;
/**
 *hashCode（） 相当于地址
 * 
 * 已知HashSet会先判断hashCode（）
 * 相同：不存
 * 不同：判断equals()
 * == hashCode不同 
 * */
public class TestHashSet {
	public static void main(String[] args) {
			
			HashSet set=new HashSet();
			SoftwareEngineer se1=new SoftwareEngineer(10, 1001);
			SoftwareEngineer se2=new SoftwareEngineer(10, 1002);
			SoftwareEngineer se3=new SoftwareEngineer(10, 1002);
			SoftwareEngineer se4=new SoftwareEngineer(10, 1003);
			SoftwareEngineer se5=new SoftwareEngineer(10, 1001);
			System.out.println("--------------------");
			set.add(se1);
			set.add(se2);
			set.add(se3);
			set.add(se4);
			set.add(se5);
			System.out.println("--------------------");
			
			System.out.println(set.size());
			
			System.out.println("----------");

			
			SoftwareEngineer se6=new SoftwareEngineer(10, 1001);
			set.add(se6);

                      // 输出的时候，会调用hashcode（）方法.	这点我也不明白

                     System.out.println(se6);  

                     System.out.println(set.size());

        }

}         	

输出结果：

--------------------
hashCode被调用
hashCode被调用
hashCode被调用
equlals被调用
hashCode被调用
hashCode被调用
equlals被调用
--------------------
3
----------
hashCode被调用
equlals被调用
hashCode被调用
com.demo.lesson13.SoftwareEngineer@3f4
3

6.

List集合

特有方法

Object get（int index）；      //获取当前下标的元素

Object set（int index，Object element）；        //修改当前下标的元素

void add（int index，Object element）；            //在当前下标添加某元素（注意与set（）的区别）

Object remove（int index）；        //移出当前下标的元素

int indexOf（Object o）；            //获取第一个当前元素的下标    （从前向后）

int lastIndexOf（Object o）；        //获取第一个当前元素的下标    （从后向前）

Arrays里面的方法：

List  asList(数组类型 a)；    //将 数组转换为List集合

7.

ArrayList集合与LinkedList集合的区别

ArrayList：类似于数组结构----->查询快，增删改慢
 

LinkedList：链表式结构------>查询慢，增删改块

8.

Collections是集合类中的一个工具类/帮助类，用于对集合中的元素进行排序（注意：有些只适用于List集合）、搜索等

常用方法：

void sort(List<T> list);    //从小到大排序

void shuffle(List<T> list)；    //错乱排序

void reverse(List<T> list);      //按元素当前顺序，倒序排序   如 :：1  5 8   6，排序后：  6   8   5   1

void fill( List<? super T> list, T obj);   //给List集合填充某元素

9.

HashMap集合：

特有方法：

put(K key ,V value);      //向Map集合中添加一个键值对。

get（Object key）；       //获取键所对应的值，若没有，则返回null

Map集合的两种遍历方式

public static void main(String[] args) {
			Map map=new HashMap();
			map.put("name", "zhansan");
			map.put("gender", "nan");
			map.put("address", "hrb");
			System.out.println(map);
			
			/*
			 * key值不可重复，并不是语法上不允许，
			 * 而是如果key值重复，则会将原key所对应的value值，
			 * 替换为新的value值，等同于一次对value的修改操作
			 *  因此，也可以将put（）用于修改某个键上的值 */
		//	map.put("name", "李四");
			System.out.println(map);
			
			
			/*
			 * Map集合的遍历需要依靠entrySet（）
			 * 其核心思路是根据Map集合，生成一个新的Set集合
			 * Set集合中装载的就是Map集合中所有数据（键值对）
			 * 那么遍历Set集合，就等同于在遍历Map
			 * 
			 * 在java中键值对对应的类型为Entry类型
			 * 提供了getKey（）用来获取key值，getValue（）获取value值
			 * 如果没有使用泛型，则集合存取是按照Object类型存取的，
			 * Iterator的next（）返回值默认是Object类型，要注意强制类型转换异常
			 * */
			
			//第一种  enteySet（）  键值对的集合
			Set set =map.entrySet();
			Iterator it=set.iterator();
			while(it.hasNext()){
				Entry entry= (Entry) it.next();
				String key=(String)entry.getKey();
				String value=(String)entry.getValue();
				System.out.println("当前键值对的键为："+key+",value为："+value);
			}
		
			System.out.println("-----------------------------");
			//第二种  keySet（）  键的集合		
			it=map.keySet().iterator();
			while(it.hasNext()){
				String key=(String) it.next();
				String value=(String)map.get(key);
				System.out.println("当前键值对的键为："+key+",value为："+value);			
				
			}
					
	}

10.

集合的排序：

  sort排序是升序排序
  自然排序：
 （1.）数字：按从小到大 1<2<3<4<5...
 （2.）字符串：zhangsan  >zhangsi
          z h a n g s a n （前）
          z h a n g s i

 （3.）自己写的类:比较指定属性值

集合自定义排序的两种方式：

（1.）重写compareto方法

注意：1.实现Comparable接口   2.重写compareTo（）方法

举例：

public class Engineer implements Comparable {
	private String name;
	private int age;
	private int year;
	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;
	}

	public int getYear() {
		return year;
	}

	public void setYear(int year) {
		this.year = year;
	}

	public int getNo() {
		return no;
	}

	public void setNo(int no) {
		this.no = no;
	}

	private int no;
	
	public Engineer(String name,int age,int year,int no){
		this.name=name;
		this.age=age;
		this.year=year;
		this.no=no;
	}
	//测试
	public static void main(String[] args) {
		//打乱下顺序试试
		Engineer e1=new Engineer("zhansan", 20, 40, 1001);
		Engineer e2=new Engineer("lisi", 30, 20, 1002);
		Engineer e3=new Engineer("wangwu", 50, 30, 1003);
		Engineer e4=new Engineer("zhaoliu", 40, 502, 1004);
		ArrayList list=new ArrayList();
		
		//根据compareTo（）的规则比较后，若是相同，再根据输出的内容比较一下
		list.add(e1);
		list.add(e2);
		list.add(e3);
		list.add(e4);
		Collections.sort(list);  //排序
		System.out.println(list);
	}

	//重写toString方法  用来辨别  排序后 ，集合中元素的顺序
	public String toString() {
		return this.name;
	}
        @Override   
	public int compareTo(Object o) {    //重写了compareTo
	Engineer e=(Engineer)o;
	//字符串比较   （根据名字比较）
	return this.name.compareTo(e.name);
			
	//值比较	根据工龄比较  return this.year-e.year;
	}

}

（2.）比较器（comparator）排序。推荐

注意：1.比较器要实现Comparator接口   2.重写compare方法

创建两个比较器

public class AgeCompator implements Comparator {  //年龄比较器
	@Override
	public int compare(Object o1, Object o2) {
		Engineer e1=(Engineer)o1;
		Engineer e2=(Engineer)o2;
		return e1.getAge()-e2.getAge();
	}

}

public class NameComparator implements Comparator<Engineer> {    //名字比较器
	@Override     
	public int compare(Engineer o1, Engineer o2) {
		
		return o1.getName().compareTo(o2.getName());
	}


}

创建一个测试类

public class TestComp {

	/**
	 * 测试比较器Compator
	 */
	public static void main(String[] args) {
		ArrayList list=new ArrayList();
		Engineer e1=new Engineer("1", 40, 40, 1001);
		Engineer e2=new Engineer("2", 50, 30, 1002);
		Engineer e3=new Engineer("3", 30, 20, 1003);
		Engineer e4=new Engineer("4", 10, 10, 1004);
		list.add(e1);
		list.add(e2);
		list.add(e3);
		list.add(e4);
		System.out.println(list);
		System.out.println("---------------");
		AgeCompator ageComp=new AgeCompator();
		//这里是实现conparator，重写conpare的比较器方法，按年龄排序
		Collections.sort(list,ageComp);
		System.out.println(list);
		System.out.println("--------------------");
		
		NameComparator nameComp=new NameComparator();
		Collections.sort(list, nameComp);
		System.out.println(list);
		
	}

}

--------------

若是有什么疑问或者新的见解，，欢迎讨论~

技术交流群： 167692269