集合

Java 中的集合是工具类，可以存储任意数量的具有共同属性的对象

应用场景

• 无法预测存储数据的数量
• 同时存储有一对一关系的数据
• 需要进行数据的增删
• 解决数据重复问题

集合框架

Collection

存储类的对象

子接口及实现类

• List：数据有序，允许重复
  • ArrayList
  • LinkedList
• Queue：数据有序，允许重复
  • LinkedList
• Set：数据无序，不允许重复
  • HashSet

Map

键值对

实现类

• HashMap

List

序列，代表元素有序并且可以重复的集合，每个元素都有其对应的顺序索引

• 可以精确控制每个元素的插入位置，或删除某个位置的元素
• 两个主要实现类是 ArrayList 和 LinkedList

ArrayList

• 基于数组实现的 List 类，是 Java 数组的有效替代品
• 自动扩容，多数情况下无需指定最大长度
• 数据在内存中是连续紧密存储的，基于数据访问速度快
• 元素有序且可以重复
• 在列表的尾部插入或删除数据非常有效
• 更适合查找和更新元素
• 其中的元素可以为 null
• 方法
  • add
  • remove
  • contains
  • isEmpty
  • indexOf
  • size
  • get

package com.imooc.set;

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

public class ListDemo1 {
	public static void main(String[] args) {
		// 用 ArrayList 存储元素
		List list = new ArrayList();
		list.add("Java");
		list.add("C");
		list.add("C++");
		list.add("Go");
		list.add("Swift");
		// 输出列表中的元素个数
		System.out.println(list.size());
		// 打印列表中的元素
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("===============");
		// 移除某个元素
		list.remove(2);
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("===============");
		list.remove("Go");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
}

Set

代表无序、不可重复的集合

迭代器

• Iterator 接口以统一的方式对各种集合元素进行遍历
• HasNext() 方法检测集合中是否还有下一个元素
• next() 方法返回集合的下一个元素

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

HashSet

• HashSet 是 Set 的一个重要实现类，称为哈希集
• HashSet 中的元素无序并且不可以重复
  • 根据重写对象所在类的 HashCode 和 equals 方法来判断两个对象是否相等
• HashSet 中只允许一个 null 元素
• 具有良好的存取和查找性能

package com.imooc.set;

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

public class SetDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Set set = new HashSet();
		set.add("red");
		set.add("green");
		set.add("blue");
		// 显示集合元素
		Iterator it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		System.out.println("=============");
		// 插入元素
		set.add("black");
		it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		System.out.println("=============");
		// 插入重复元素，插入失败，但是是不会报错
		set.add("black");
		it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

@Override
public boolean equals(Object obj) {
  //判断对象是否相等，相等则返回true，不用继续比较属性了
  if(this==obj)
    return true;
  //判断obj是否是Cat类的对象
  if(obj.getClass()==Cat.class){
    Cat cat=(Cat)obj;
    return cat.getName().equals(name)&&(cat.getMonth()==month)&&(cat.getSpecies().equals(species));
  }
  return false;
}

Map

代表存储映射关系的集合

• Map 中的数据是以键值对 key-value 的形式存储的
• Key-value 以 Entry 类型的对象实例存在
• 可以通过 key 值快速的查找 value
• 一个映射不能包含重复的建
• 每个键最多只能映射到一个值

HashMap

• 基于哈希表的 Map 接口的实现

• 允许使用null 键和 null 值

• 键不允许重复

• HashMap 中的 Entry 对象是无序排列的

• 方法

  • 查找数据：keySet()

    • Set<String> keySet = classObj.keySet();
      for(String key:keySet){
        if(str.equals(key)){
          System.out.println(classObj.get(key));
          break;
        }
      }
      

  • 添加数据：put(key,value)

  • 打印数据：

    • 使用迭代器打印值：Iterator -> classObj.values().iterator()

    • 通过 entrySet 打印 key 和 value

      • Set<Entry<String,String>> entrySet = classObj.entrySet();
        for(Entry<String,String> entry:entrySet){
          System.out.println(entry.getKey());
          System.out.println(entry.getValue());
        }
        
        

Queue

代表队列特性

集合排序

使用 Collections 类的 sort() 方法

• sort(List<T> list)：根据元素的自然顺序对指定列表按升序进行排序

整数排序

package com.imooc.set;

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

public class SortDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Integer> list = new ArrayList();
		list.add(3);
		list.add(1);
		list.add(4);
		list.add(2);
		for (int n : list) {
			System.out.print(n + " ");
		}
		System.out.println("");
		System.out.println("-------");
		Collections.sort(list);
		for (int n : list) {
			System.out.print(n + " ");
		}
	}
}

字符串排序

package com.imooc.set;

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

public class SortDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> list = new ArrayList();
		list.add("orange");
		list.add("blue");
		list.add("yellow");
		list.add("gray");
		for (String str : list) {
			System.out.print(str + " ");
		}
		System.out.println("");
		System.out.println("-----------------------");
		Collections.sort(list);
		for (String n : list) {
			System.out.print(n + " ");
		}
	}
}

对象排序

Comparator

• 强行对某个对象进行整体排序的比较函数

• 可以将 Comparator 传递给 sort 方法

  • Collections.sort
  • Arrays.sort

• 方法

  • int compare(T o1, T o2)：比较用来排序的两个参数
    • 如果 o1<o2，返回 负整数
    • 如果 o1==o2，返回 0
    • 如果 o1>o2，返回 正整数
  • boolean equals(Object obj)：只是某个对象是否 “等于” 此 Comparator
    • 此方法可以被 Object 类中的 equals 方法覆盖，不必重写

// Cat.java
package com.imooc.sort;
public class Cat {
	private String name; //名字
	private int month; //年龄
	private String species;//品种
	//构造方法
	public Cat(String name, int month, String species) {
		super();
		this.name = name;
		this.month = month;
		this.species = species;
	}
  // getter与setter方法
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getMonth() {
		return month;
	}
	public void setMonth(int month) {
		this.month = month;
	}
	public String getSpecies() {
		return species;
	}
	public void setSpecies(String species) {
		this.species = species;
	}
	@Override
	public String toString() {
		return "[名字：" + name + ", 年龄：" + month + ", 品种：" + species + "]";
	}
}

// NameComparator.java
package com.imooc.sort;
import java.util.Comparator;
public class NameComparator implements Comparator<Cat> {
	@Override
	public int compare(Cat o1, Cat o2) {
		// 按名字升序排序
		String name1=o1.getName();
		String name2=o2.getName();
		int n=name1.compareTo(name2);
		return n;
	}
}

// AgeComparator.java
package com.imooc.sort;
import java.util.Comparator;
public class AgeComparator implements Comparator<Cat>{
	@Override
	public int compare(Cat o1, Cat o2) {
		// 按年龄降序排序
		int age1=o1.getMonth();
		int age2=o2.getMonth();
		return age2-age1;
	}
}


// CatTest.java
package com.imooc.sort;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CatTest {
	public static void main(String[] args) {
		// 按名字升序排序
		Cat huahua=new Cat("huahua",5,"英国短毛猫");
		Cat fanfan=new Cat("fanfan",2,"中华田园猫");
		Cat maomao=new Cat("maomao",3,"中华田园猫");
		List<Cat> catList=new ArrayList<Cat>();
		catList.add(huahua);
		catList.add(fanfan);
		catList.add(maomao);
		//排序前
		System.out.println("排序前：");
		for(Cat cat:catList){
			System.out.println(cat);
		}
		//按名字进行升序排序
		Collections.sort(catList, new NameComparator());
		System.out.println("按名字升序排序后：");
		for(Cat cat:catList){
			System.out.println(cat);
		}
		//按年龄进行降序排序
		Collections.sort(catList, new AgeComparator());
		System.out.println("按年龄降序排序后：");
		for(Cat cat:catList){
			System.out.println(cat);
		}
	}
}

Comparable

• 此接口强行对实现它的每个类的对象进行整体排序

• 这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法

  • Collections.sort
  • Arrays.sort

• 方法

  • int compareTo(T o)：该对象小于、等于、大于指定对象，则分别返回负整数、零、正整数

// Goods.java
package com.imooc.sort;
public class Goods implements Comparable<Goods> {
	private String id;// 商品编号
	private String name;// 商品名称
	private double price;// 商品价格
	// 构造方法
	public Goods(String id, String name, double price) {
		this.id = id;
		this.name = name;
		this.price = price;
	}
	// getter和setter方法
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public String toString() {
		return "商品编号：" + id + ",商品名称：" + name + "，商品价格：" + price;
	}
	@Override
	public int compareTo(Goods o) {
		// 取出商品价格
		double price1 = this.getPrice();
		double price2 = o.getPrice();
		int n = new Double(price2 - price1).intValue();
		return n;
	}
}

// GoodsTest.java
package com.imooc.sort;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class GoodsTest {
	public static void main(String[] args) {
		Goods g1 = new Goods("s00001", "手机", 2000);
		Goods g2 = new Goods("s00002", "冰箱", 5000);
		Goods g3 = new Goods("s00003", "电视机", 3000);
		List<Goods> goodsList = new ArrayList<Goods>();
		goodsList.add(g1);
		goodsList.add(g2);
		goodsList.add(g3);
		// 排序前
		System.out.println("排序前：");
		for (Goods goods : goodsList) {
			System.out.println(goods);
		}
		Collections.sort(goodsList);
		// 排序后
		System.out.println("排序后：");
		for (Goods goods : goodsList) {
			System.out.println(goods);
		}
	}
}

区别

Comparator	Comparable
位于 java.util 包	位于 java.lang 包
在要比较的类的外部实现该接口	再要比较的类上实现该接口
调用 sort 方法时，要指定 Comparator 的实现类	调用 sort 方法时，只需要指定集合名称即可