JAVA集合框架

最新推荐文章于 2024-02-28 09:56:44 发布

爱打羽球的码猿

最新推荐文章于 2024-02-28 09:56:44 发布

阅读量144

点赞数

分类专栏： Java 集合文章标签： java 集合

本文链接：https://blog.csdn.net/weixin_46822367/article/details/114855817

版权

Java 同时被 2 个专栏收录

59 篇文章 5 订阅

订阅专栏

集合

1 篇文章 0 订阅

订阅专栏

JAVA集合框架

在这里插入图片描述

JAVA集合框架

JAVA集合框架

1.1 Collection接口的使用（1）

/**
 * Collection接口的使用
 * （1）添加元素
 * （2）删除元素
 * （3）遍历元素
 * （4）判断
 * @author LYP
 *
 */
public class CollectionDemo1 {

	public static void main(String[] args) {
		// 创建集合
		Collection collection = new ArrayList();
//	 	* （1）添加元素
		collection.add("苹果");
		collection.add("西瓜");
		collection.add("榴莲");
		System.out.println("元素个数："+collection.size());
		System.out.println(collection);
//	 	* （2）删除元素
//		collection.remove("榴莲");
//		collection.clear();
//		System.out.println("删除之后:"+collection.size());
//	 	* （3）遍历元素
		//3.1使用增强for
		System.out.println("--------3.1使用增强for------");
		for(Object object :collection) {
			System.out.println(object);
		} 
		//3.2使用迭代器（专门遍历集合的一种方式）
		//hasNext();有没有下一个元素
		//next();获取下一个元素
		//remove();删除当前元素
		System.out.println("--------3.2使用增强for------");
		Iterator it = collection.iterator();
		while(it.hasNext()) {
			String s = (String)it.next();
			System.out.println(s);
			//不能使用collection删除方法
			//collection.remove(s);
			//it.remove();
		}
		System.out.println("元素个数"+collection.size());

		
//	 	* （4）判断
		System.out.println(collection.contains("西瓜"));
		System.out.println(collection.isEmpty());
	}

}

运行结果：

元素个数：3
[苹果, 西瓜, 榴莲]
--------3.1使用增强for------
苹果
西瓜
榴莲
--------3.2使用增强for------
苹果
西瓜
榴莲
元素个数3
true
false

1.2 Collection接口的使用（2）

/**
 * Collection的使用：保存学生信息
 * @author LYP
 *
 */
public class CollectionDemo2 {

	public static void main(String[] args) {
		//新建collection 对象
		Collection collection = new ArrayList();
		Student s1 = new Student("张三",20);
		Student s2 = new Student("王五",18);
		Student s3 = new Student("柳高",15);
		//1添加数据
		collection.add(s1);
		collection.add(s2);
		collection.add(s3);
		System.out.println("元素个数："+collection.size());
		System.out.println(collection.toString());
		//2删除
		//collection.remove(s1);
		//collection.remove(new Student("柳高",15));
		//collection.clear();
		System.out.println("删除之后："+collection.size());
		//3遍历
		//3.1增强for
		System.out.println("----------增强for--------");
		for(Object object : collection) {
			Student s = (Student)object;
			System.out.println(s.toString());
		}
		//3.2迭代器 ： hasNext() next()  remove()
		//迭代过程中不能使用collection的删除方法
		System.out.println("----------迭代器 --------");
		Iterator it = collection.iterator();
		while(it.hasNext()) {
			Student s = (Student)it.next();
			System.out.println(s.toString());
		}
		//4判断
		System.out.println(collection.contains(s1));
		System.out.println(collection.isEmpty());
	}

}

运行结果：

元素个数：3
[Student [name=张三, age=20], Student [name=王五, age=18], Student [name=柳高, age=15]]
删除之后：3
----------增强for--------
Student [name=张三, age=20]
Student [name=王五, age=18]
Student [name=柳高, age=15]
----------迭代器 --------
Student [name=张三, age=20]
Student [name=王五, age=18]
Student [name=柳高, age=15]
true
false

2.1 List子接口的使用

/**
 * List子接口的使用
 * 特点 1 有序有下标 2 可以重复
 * @author LYP
 *
 */
public class ListDemo1 {

	private static ListIterator listIterator;

	public static void main(String[] args) {

		List list = new ArrayList<>();
		//1添加元素
		list.add("苹果");
		list.add("小米");
		list.add(0,"华为");
		System.out.println("元素个数：" +list.size());
		System.out.println(list.toString());
		//2删除
//		list.remove("苹果");
//		list.remove(0);
		//3遍历
		//3.1使用for遍历
		System.out.println("----------3.1使用for遍历-----------");
		for(int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		//3.2使用增强for
		System.out.println("----------3.2使用增强for-----------");
		for(Object object : list) {
			System.out.println(object);
		}
		//3.3使用迭代器
		System.out.println("----------3.3使用迭代器-----------");
		Iterator it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//3.4使用列表迭代器   ListIterator 可以向前向后遍历、添加、删除、修改元素
		ListIterator lit = list.listIterator();
		System.out.println("----------3.4使用列表迭代器  从前往后-----------");
		while(lit.hasNext()) {
			System.out.println(lit.nextIndex()+":"+lit.next());
		}
		System.out.println("----------3.5使用列表迭代器  从后往前-----------");
		while(lit.hasPrevious()) {
			System.out.println(lit.previousIndex()+":"+lit.previous());
		}
		
		//4判断
		System.out.println(list.contains("苹果"));
		System.out.println(list.isEmpty());
		
		//5获取位置
		System.out.println(list.indexOf("华为"));
	}

}

运行结果：

元素个数：3
[华为, 苹果, 小米]
----------3.1使用for遍历-----------
华为
苹果
小米
----------3.2使用增强for-----------
华为
苹果
小米
----------3.3使用迭代器-----------
华为
苹果
小米
----------3.4使用列表迭代器  从前往后-----------
0:华为
1:苹果
2:小米
----------3.5使用列表迭代器  从后往前-----------
2:小米
1:苹果
0:华为
true
false
0

List子接口的使用（2）

public class ListDemo2 {
	public static void main(String[] args) {
		List list = new ArrayList();
		//1.添加数字数据（自动装箱）
		list.add(20);
		list.add(30);
		list.add(40);
		list.add(50);
		list.add(60);
		System.out.println("元素个数"+list.size());
		System.out.println(list.toString());
		//2.删除操作
		//list.remove(0);
		//list.remove(new Integer(20));
		//list.remove((Object)20);
		System.out.println("删除元素："+list.size());
		System.out.println(list.toString());
		
		//3.subList ,返回子集合 ,含头不含尾
		List sublist = list.subList(1, 3);
		System.out.println(sublist.toString());
	}
	
}

运行结果：

元素个数5
[20, 30, 40, 50, 60]
删除元素：5
[20, 30, 40, 50, 60]
[30, 40]

2.1.1 ArrayList的使用（1）

/**
 * ArrayList的使用
 * 存储结构：数组 查找遍历速度快  增删慢
 * @author LYP
 *
 */
public class ArrayListDemo {

	public static void main(String[] args) {
		//新建ArrayList 对象
		ArrayList arrayList = new ArrayList<>();
		Student s1 = new Student("刘德华",20);
		Student s2 = new Student("郭富城",18);
		Student s3 = new Student("马云",15);
		//1添加数据
		arrayList.add(s1);
		arrayList.add(s2);
		arrayList.add(s3);
		System.out.println("元素个数："+arrayList.size());
		System.out.println(arrayList.toString());
		//2删除
		//arrayList.remove(new Student("马云",15));//equals(this == obj
		//System.out.println("删除之后："+arrayList.size());
		//3遍历
		//3.1增强for
		System.out.println("----------3.1增强for--------");
		for(Object object : arrayList) {
			Student s = (Student)object;
			System.out.println(s.toString());
		}
		//3.2迭代器 ： hasNext() next()  remove()
		System.out.println("----------3.2迭代器 --------");
		Iterator it = arrayList.iterator();
		while(it.hasNext()) {
			Student s = (Student)it.next();
			System.out.println(s.toString());
		}
		//3.3使用列表迭代器   ListIterator 可以向前向后遍历、添加、删除、修改元素
		ListIterator lit = arrayList.listIterator();
		System.out.println("----------3.3使用列表迭代器  从前往后-----------");
		while(lit.hasNext()) {
			System.out.println(lit.nextIndex()+":"+lit.next());
		}
		System.out.println("----------3.4使用列表迭代器  从后往前-----------");
		while(lit.hasPrevious()) {
			System.out.println(lit.previousIndex()+":"+lit.previous());
		}
				
		//4判断
		System.out.println(arrayList.contains(new Student("刘德华",20)));
		System.out.println(arrayList.isEmpty());

	}

}

运行结果：

元素个数：3
[Student [name=刘德华, age=20], Student [name=郭富城, age=18], Student [name=马云, age=15]]
----------3.1增强for--------
Student [name=刘德华, age=20]
Student [name=郭富城, age=18]
Student [name=马云, age=15]
----------3.2迭代器 --------
Student [name=刘德华, age=20]
Student [name=郭富城, age=18]
Student [name=马云, age=15]
----------3.3使用列表迭代器  从前往后-----------
0:Student [name=刘德华, age=20]
1:Student [name=郭富城, age=18]
2:Student [name=马云, age=15]
----------3.4使用列表迭代器  从后往前-----------
2:Student [name=马云, age=15]
1:Student [name=郭富城, age=18]
0:Student [name=刘德华, age=20]
true
false

2.1.2 ArrayList的使用（2）

public class ArrayListDemo2 {

	public static void main(String[] args) {

			ArrayList<String> arrayList = new ArrayList<String>();
			arrayList.add("咖啡");
			arrayList.add("巧克力");
			//arrayList.add(454);
			for(String string : arrayList) {
				System.out.println(string);
			}
			
			Student s1 = new Student("刘德华",20);
			Student s2 = new Student("郭富城",18);
			Student s3 = new Student("马云",15);
			ArrayList<Student> arrayList2 = new ArrayList<Student>();
			arrayList2.add(s1);
			arrayList2.add(s2);
			arrayList2.add(s3);
			
			Iterator<Student> it = arrayList2.iterator();
			while(it.hasNext()) {
				Student s = it.next();
				System.out.println(s.toString());
			}
	}

}

运行结果：

咖啡
巧克力
Student [name=刘德华, age=20]
Student [name=郭富城, age=18]
Student [name=马云, age=15]

2.2.1 Vector的使用

/**
 * Vector的使用
 * 存储结构：数组
 * @author LYP
 *
 */
public class VectorDemo {

	public static void main(String[] args) {
		Vector vector = new Vector<>();
		//1.添加
		vector.add("苹果");
		vector.add("香蕉");
		vector.add("橘子");
		System.out.println("元素个数"+vector.size());
		//2.删除
//		vector.remove(0);
//		vector.remove("苹果");
//		vector.clear();
		//3.遍历
		Enumeration en = vector.elements();
		while(en.hasMoreElements()) {
			String o = (String)en.nextElement();
			System.out.println(o);
		}
		//4.判断
		System.out.println(vector.contains("香蕉"));
		System.out.println(vector.isEmpty());
		//vector 其他方法
		//firstElement、 lastElement elementAt()
	}

}

运行结果：

元素个数3
苹果
香蕉
橘子
true
false

2.3.1 LinkedList 的使用

/**
 * LinkedList 的使用
 * 存储结构：双向链表
 * @author LYP
 *
 */
public class LinkedListDemo {

	public static void main(String[] args) {
		LinkedList linkedList = new LinkedList<>();
		Student s1 = new Student("刘德华",20);
		Student s2 = new Student("郭富城",18);
		Student s3 = new Student("马云",15);
		//1.添加
		linkedList.add(s1);
		linkedList.add(s2);
		linkedList.add(s3);
		System.out.println("元素个数为："+ linkedList.size());
		System.out.println(linkedList.toString());
//		//2.删除
//		linkedList.remove(s1);
//		linkedList.clear();
//		System.out.println("元素个数为："+ linkedList.size());
		//3.遍历
		//3.1for遍历
		System.out.println("----------3.1for遍历--------------");
		for(int i = 0;i < linkedList.size(); i++) {
			System.out.println(linkedList.get(i));
		}
		//3.2增强for
		System.out.println("----------3.2增强for--------------");
		for(Object object : linkedList) {
			Student s = (Student)object;
			System.out.println(s.toString());
		}
		//3.3迭代器
		System.out.println("----------3.3迭代器--------------");
		Iterator it = linkedList.iterator();
		while(it.hasNext()) {
			Student s = (Student)it.next();
			System.out.println(s.toString());
		}
		//3.4列表迭代器
		System.out.println("----------3.4列表迭代器--------------");
		ListIterator lit = linkedList.listIterator();
		while(lit.hasNext()) {
			Student s = (Student)lit.next();
			System.out.println(s.toString());
		}
		//4.判断
		System.out.println(linkedList.contains(s1));
		System.out.println(linkedList.isEmpty());
		//5.获取
		System.out.println(linkedList.indexOf(s2));
		
	}

}

运行结果：

元素个数为：3
[Student [name=刘德华, age=20], Student [name=郭富城, age=18], Student [name=马云, age=15]]
----------3.1for遍历--------------
Student [name=刘德华, age=20]
Student [name=郭富城, age=18]
Student [name=马云, age=15]
----------3.2增强for--------------
Student [name=刘德华, age=20]
Student [name=郭富城, age=18]
Student [name=马云, age=15]
----------3.3迭代器--------------
Student [name=刘德华, age=20]
Student [name=郭富城, age=18]
Student [name=马云, age=15]
----------3.4列表迭代器--------------
Student [name=刘德华, age=20]
Student [name=郭富城, age=18]
Student [name=马云, age=15]
true
false
1

3.1 泛型

3.1.1 泛型类

/**
 * 泛型类
 * 语法，类名<T>
 * T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开
 * @author LYP
 *
 */

public class MyGeneric<T> {
		//使用泛型
		//1.创建变量
		T t;
		
		//2.泛型作为方法的参数
		public void show(T t) {
			System.out.println(t);
		}
		//3.泛型作为方法的返回值
		public T getT() {
			return t;
		}

}

3.1.2 泛型方法

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

3.1.3 泛型接口

/**
 * 泛型接口
 * 语法 接口名<T>
 * 注意 不能泛型静态常量
 * @author ASUS
 *
 */
public interface MyInterface<T> {
	String name = "张三";
	
	T server(T t);
}

3.1.4 泛型接口的实现类（1）

public class MyInterfaceImpl implements MyInterface<String>{

	@Override
	public String server(String t) {
		// TODO Auto-generated method stub
		System.out.println(t);
		return t;
	}

	
}

3.1.5 泛型接口的实现类（2）

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

	@Override
	public T server(T t) {
		System.out.println(t);
		return t;
	}

}

3.2 泛型的测试类

public class TestGeneric {
	public static void main(String[] args) {
		//使用泛型类创建对象
		//注意： 1.泛型只能是引用类型 2.不同的泛型类型对象之间不能相互赋值
		
		//泛型类
		MyGeneric<String> myGeneric = new MyGeneric<String>();
		myGeneric.t= "hello";
		myGeneric.show("大家好啊");
		String string = myGeneric.getT();
		
		MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
		myGeneric2.t = 100;
		myGeneric2.show(200);
		Integer integer = myGeneric2.getT();
		
		//泛型接口
		MyInterfaceImpl impl = new MyInterfaceImpl();
		impl.server("xxxxxxxxxxxxx");
		
		MyInterfaceImpl2<Integer> impl2 = new MyInterfaceImpl2<>();
		impl2.server(1000);
		
		//泛型方法
		MyGenericMethod myGenericMethod = new MyGenericMethod();
		myGenericMethod.show("中国加油");
		myGenericMethod.show(200);
		myGenericMethod.show(3.1415926);
	}

}

运行结果：

大家好啊
200
xxxxxxxxxxxxx
1000
泛型方法中国加油
泛型方法200
泛型方法3.1415926

4.1 Set接口的使用

/**
 * 测试Set接口的使用
 * 特点 （1）无序、没有下标 （2） 不能重复
 * @author LYP
 *
 */
public class SetDemo {

	public static void main(String[] args) {
		//创建集合
		Set<String> set = new HashSet<>();
		//1.添加数据
		set.add("小米");
		set.add("华为");
		set.add("苹果");
		//set.add("华为");
		System.out.println("元素个数:" + set.size());
		System.out.println(set.toString());
//		//2.删除数据
//		set.remove("小米");
//		System.out.println(set.toString());
		//3.遍历
		//3.1使用增强for
		System.out.println("---------3.1使用增强for-------");
		for(String string : set) {
			System.out.println(string);
		}
		//3.2使用迭代器
		System.out.println("---------3.2使用迭代器-------");
		Iterator<String> it = set.iterator();
		while(it.hasNext()) {
			String s = it.next();
			System.out.println(s.toString());
		}
		//4.判断
		System.out.println(set.contains("华为"));
		System.out.println(set.isEmpty());
		
	}

}

运行结果：

元素个数:3
[苹果, 华为, 小米]
---------3.1使用增强for-------
苹果
华为
小米
---------3.2使用迭代器-------
苹果
华为
小米
true
false

4.1.1 HashSet集合的使用（1）

/**
 * HashSet集合的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * @author LYP
 *
 */
public class HashSetDemo {

	public static void main(String[] args) {
		HashSet<String> hashSet = new HashSet<>();
		//1添加元素
		hashSet.add("苹果");
		hashSet.add("小米");
		hashSet.add("华为");
		System.out.println("元素个数：" +hashSet.size());
		System.out.println(hashSet.toString());
		//2删除
//		hashset.remove("苹果");
//		hashset.remove(0);
		//3遍历
		
		//3.1使用增强for
		System.out.println("----------3.1使用增强for-----------");
		for(String string : hashSet) {
			System.out.println(string);
		}
		//3.2使用迭代器
		System.out.println("----------3.2使用迭代器-----------");
		Iterator it = hashSet.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//4.判断
		System.out.println(hashSet.contains("三星"));
		System.out.println(hashSet.isEmpty());
	}

}

运行结果：

元素个数：3
[苹果, 华为, 小米]
----------3.1使用增强for-----------
苹果
华为
小米
----------3.2使用迭代器-----------
苹果
华为
小米
false
false

4.1.2 HashSet集合的使用（2）

/**
 *  HashSet集合的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * 存储过程（重复依据）
 * （1）根据hashcode计算保存的位置，如果位置为空，则直接保存，如果不为空执行第二步
 * （2）再执行equals方法，如果equals方法为true,则认为是重复，否则形成链表
 * @author LYP
 *
 */
public class HashSetDemo2 {

	public static void main(String[] args) {
		HashSet<Person> persons = new HashSet<>();
		//1.添加数据
		Person p1 = new Person("刘德华",20);
		Person p2 = new Person("林志林",22);
		Person p3 = new Person("马化腾",25);
		
		persons.add(p1);
		persons.add(p2);
		persons.add(p3);
//		person.add(p3);重复无法添加
		persons.add(new Person("马化腾",25));
		
		System.out.println("元素个数:"+persons.size());
		System.out.println(persons.toString());
		
//		//2.删除操作
//		persons.remove(p1);
//		persons.remove(new Person("马化腾",25));
//		System.out.println("删除之后："+persons.size());
		
		//3.1使用增强for
		System.out.println("----------3.1使用增强for-----------");
		for(Person person : persons) {
			System.out.println(person);
		}
		//3.2使用迭代器
		System.out.println("----------3.2使用迭代器-----------");
		Iterator it = persons.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//4.判断
		System.out.println(persons.contains(new Person("刘德华",20)));
		System.out.println(persons.isEmpty());
	}

}

运行结果：

元素个数:3
[Person [name=林志林, age=22], Person [name=马化腾, age=25], Person [name=刘德华, age=20]]
----------3.1使用增强for-----------
Person [name=林志林, age=22]
Person [name=马化腾, age=25]
Person [name=刘德华, age=20]
----------3.2使用迭代器-----------
Person [name=林志林, age=22]
Person [name=马化腾, age=25]
Person [name=刘德华, age=20]
true
false

4.2.1 TreeSet的使用（1）

/**
 * TreeSet的使用
 * 存储结构：红黑树
 * @author LYP
 *
 */
public class TreeSetDemo {

	public static void main(String[] args) {
		TreeSet<String> treeSet = new TreeSet<>();
		//1添加元素
		treeSet.add("abc");
		treeSet.add("xyz");
		treeSet.add("hello");
		System.out.println("元素个数：" +treeSet.size());
		System.out.println(treeSet.toString());
//		//2删除
//		treeSet.remove("xyz");
//		System.out.println("删除之后："+treeSet.size());
		//3遍历
		
		//3.1使用增强for
		System.out.println("----------3.1使用增强for-----------");
		for(String string : treeSet) {
			System.out.println(string);
		}
		//3.2使用迭代器
		System.out.println("----------3.2使用迭代器-----------");
		Iterator it = treeSet.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//4.判断
		System.out.println(treeSet.contains("xyz"));
		System.out.println(treeSet.isEmpty());
	}

}

运行结果：

元素个数：3
[abc, hello, xyz]
----------3.1使用增强for-----------
abc
hello
xyz
----------3.2使用迭代器-----------
abc
hello
xyz
true
false

4.2.2 TreeSet的使用（2）

/**
 * TreeSet的使用
 * 存储结构：红黑树
 *要求：元素必须要实现Comparable接口
 * @author LYP
 *
 */
public class TreeSetDemo2 {

	public static void main(String[] args) {
		TreeSet<Person> persons = new TreeSet<>();
		//1.添加数据
		Person p1 = new Person("xyz",23);
		Person p2 = new Person("hello",22);
		Person p3 = new Person("zhangsan",25);
		Person p4 = new Person("zhangsan",20);
		
		persons.add(p1);
		persons.add(p2);
		persons.add(p3);
		persons.add(p4);
		
		System.out.println("元素个数:"+persons.size());
		System.out.println(persons.toString());
		

//		//2.删除操作
//		persons.remove(p1);
//		persons.remove(new Person("hello",22));
//		System.out.println("删除之后："+persons.size());
		
		//3.1使用增强for
		System.out.println("----------3.1使用增强for-----------");
		for(Person person : persons) {
			System.out.println(person);
		}
		//3.2使用迭代器
		System.out.println("----------3.2使用迭代器-----------");
		Iterator it = persons.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//4.判断
		System.out.println(persons.contains(new Person("hello",22)));
		System.out.println(persons.isEmpty());
	}

}

运行结果：

元素个数:4
[Person [name=hello, age=22], Person [name=xyz, age=23], Person [name=zhangsan, age=20], Person [name=zhangsan, age=25]]
----------3.1使用增强for-----------
Person [name=hello, age=22]
Person [name=xyz, age=23]
Person [name=zhangsan, age=20]
Person [name=zhangsan, age=25]
----------3.2使用迭代器-----------
Person [name=hello, age=22]
Person [name=xyz, age=23]
Person [name=zhangsan, age=20]
Person [name=zhangsan, age=25]
true
false

4.2.3 TreeSet的使用（3）

public class TreeSetDemo3 {

	public static void main(String[] args) {
		TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {

			@Override
			public int compare(Person o1, Person o2) {
				int n1 = o1.getAge() - o2.getAge();
				int n2 = o1.getName().compareTo(o2.getName());
				return n1 == 0? n2:n1;
			}
		});
		
		Person p1 = new Person("xyz",23);
		Person p2 = new Person("hello",22);
		Person p3 = new Person("zhangsan",25);
		Person p4 = new Person("lisi",25);
		
		persons.add(p1);
		persons.add(p2);
		persons.add(p3);
		persons.add(p4);
		
		System.out.println("元素个数:"+persons.size());
		System.out.println(persons.toString());
	}

}

运行结果：

元素个数:4
[Person [name=hello, age=22], Person [name=xyz, age=23], Person [name=lisi, age=25], Person [name=zhangsan, age=25]]

4.2.4 TreeSet的使用（4）

/**
 * 要求，使用TreeSet集合实现字符串按照长度进行排序
 * Comparator接口实现 比较
 * @author LYP
 *
 */
public class TreeSetDemo4 {

	public static void main(String[] args) {
		TreeSet<String> treeSet =  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;
			}
		});
		//添加数据
		treeSet.add("helloworld");
		treeSet.add("pingguo");
		treeSet.add("lisi");
		treeSet.add("zhangsan");
		treeSet.add("beijing");
		treeSet.add("cat");
		treeSet.add("nanjing");
		
		System.out.println(treeSet.toString());
	}
}

运行结果：

元素个数:4
[cat, lisi, beijing, nanjing, pingguo, zhangsan, helloworld]

5.1 Map接口的使用

/**
 * Map接口的使用
 * 特点：（1）存储键值对 （2）键不能重复，值可以重复 （3）无序
 * @author LYP
 *
 */
public class MapDemo {

	public static void main(String[] args) {
		Map<String,String> map = new HashMap<>();
		//1.添加元素
		map.put("cn","美国");
		map.put("uk","英国");
		map.put("usa","美国");
		map.put("cn","中国");
		
		System.out.println("元素个数："+map.size());
		System.out.println(map.toString());
		
//		//2.删除
//		map.remove("usa");
//		System.out.println("删除之后"+map.size());
		
		//3.遍历
		//3.1使用keySet();
		System.out.println("·············3.1使用keySet()·········");
		//Set<String> keyset = map.keySet();
		for (String key : map.keySet()) {
			System.out.println(key+"------"+map.get(key));
		}
		
		//3.2使用entrySet()方法
		System.out.println("·············3.2使用entrySet()方法·········");
		//Set<Map.Entry<String,String>> entries = map.entrySet();
		for (Map.Entry<String, String> entry : map.entrySet()) {
			System.out.println(entry.getKey()+"-----"+entry.getValue());
			
		}
		//4.判断
		System.out.println(map.containsKey("cn"));
		System.out.println(map.containsValue("泰国"));
	}

}

运行结果：

元素个数：3
{usa=美国, uk=英国, cn=中国}
·············3.1使用keySet()·········
usa------美国
uk------英国
cn------中国
·············3.2使用entrySet()方法·········
usa-----美国
uk-----英国
cn-----中国
true
false

5.1.1 HashMap集合的使用

/**
 * HashMap集合的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * 使用Key可HashCod和equals作为重复
 * @author LYP
 *
 */
public class HashMapDemo {

	public static void main(String[] args) {
		//创建集合
		HashMap<Student2,String> students = new HashMap<Student2,String>();
		//刚创建HashMap之后没有添加元素 table = null size = 0 目的是节省空间
		//1.添加元素
		Student2 s1 = new Student2("旋涡鸣人",100);
		Student2 s2 = new Student2("宇智波佐助",101);
		Student2 s3 = new Student2("旗木卡卡西",102);
		
		students.put(s1, "七代目火影");
		students.put(s2, "二柱子");
		students.put(s3, "五代目火影");
		//students.put(s3, "千鸟");
		students.put(new Student2("旋涡鸣人",100), "火影");
		System.out.println("元素个数："+students.size());
		System.out.println(students.toString());
		
//		//2.删除元素
//		students.remove(new Student2("旋涡鸣人",100), "火影");
//		System.out.println(students.size()); 
		
		//3.遍历
		//3.1使用KeySet
		System.out.println("--------------3.1使用KeySet---------------");
		for (Student2 key : students.keySet()) {
			System.out.println(key.toString()+"-----"+students.get(key));
		}
		//3.2使用entrySet
		System.out.println("--------------3.2使用entrySet---------------");
		for (Map.Entry<Student2, String> entry : students.entrySet()) {
			System.out.println(entry.getKey()+"------"+entry.getValue());
		}
		//4.判断
		System.out.println(students.containsKey(new Student2("旗木卡卡西",102)));
		System.out.println(students.containsValue("二柱子"));
		
	}

}

运行结果：

元素个数：3
{Student2 [name=旗木卡卡西, stuNo=102]=五代目火影, Student2 [name=旋涡鸣人, stuNo=100]=火影, Student2 [name=宇智波佐助, stuNo=101]=二柱子}
--------------3.1使用KeySet---------------
Student2 [name=旗木卡卡西, stuNo=102]-----五代目火影
Student2 [name=旋涡鸣人, stuNo=100]-----火影
Student2 [name=宇智波佐助, stuNo=101]-----二柱子
--------------3.2使用entrySet---------------
Student2 [name=旗木卡卡西, stuNo=102]------五代目火影
Student2 [name=旋涡鸣人, stuNo=100]------火影
Student2 [name=宇智波佐助, stuNo=101]------二柱子
true
true

5.2.1 TreeMap 的使用

/**
 * TreeMap 的使用
 * 存储结构：红黑树
 * @author LYP
 *
 */
public class TreeMapDemo {

	public static void main(String[] args) {
		//新建集合
		TreeMap<Student2,String> treeMap = new TreeMap<>();
		//1.添加元素
		Student2 s1 = new Student2("旋涡鸣人",100);
		Student2 s2 = new Student2("宇智波佐助",101);
		Student2 s3 = new Student2("旗木卡卡西",102);
		treeMap.put(s1, "七代目火影");
		treeMap.put(s2, "二柱子");
		treeMap.put(s3, "五代目火影");
		
		treeMap.put(new Student2("旗木卡卡西",102), "千鸟");
		System.out.println("元素个数为："+treeMap.size());
		System.out.println(treeMap.toString());
		
//		//2.删除元素
//		treeMap.remove(new Student2("旗木卡卡西",102));
//		System.out.println("删除之后："+treeMap.size());
		
		//3.遍历
		//3.1使用keySet()
		System.out.println("--------------3.1使用keySet()--------------");
		for (Student2 key : treeMap.keySet()) {
			System.out.println(key.toString()+"-----"+treeMap.get(key));
		}
		//3.2使用entrySet()
		System.out.println("--------------3.2使用entrySet()--------------");
		for (Map.Entry<Student2, String> entry : treeMap.entrySet()) {
			System.out.println(entry.getKey()+"------"+entry.getValue());
		}
		
		//4.判断
		System.out.println(treeMap.containsKey(new Student2("旗木卡卡西",102)));
		System.out.println(treeMap.containsValue("七代目火影"));
	}
}

运行结果：

元素个数为：3
{Student2 [name=旋涡鸣人, stuNo=100]=七代目火影, Student2 [name=宇智波佐助, stuNo=101]=二柱子, Student2 [name=旗木卡卡西, stuNo=102]=千鸟}
--------------3.1使用keySet()--------------
Student2 [name=旋涡鸣人, stuNo=100]-----七代目火影
Student2 [name=宇智波佐助, stuNo=101]-----二柱子
Student2 [name=旗木卡卡西, stuNo=102]-----千鸟
--------------3.2使用entrySet()--------------
Student2 [name=旋涡鸣人, stuNo=100]------七代目火影
Student2 [name=宇智波佐助, stuNo=101]------二柱子
Student2 [name=旗木卡卡西, stuNo=102]------千鸟
true
true

6.1 Collections 工具类的使用


/**
 * 展示Collections 工具类的使用
 * @author LYP
 *
 */
public class CollectionToolsDemo {

	public static void main(String[] args) {
		List<Integer> list = new ArrayList<>();
		list.add(20);
		list.add(3);
		list.add(2);
		list.add(65);
		list.add(6);
		list.add(234);
		
		//sort排序
		System.out.println("排序前："+list.toString());
		Collections.sort(list);
		System.out.println("排序后："+list.toString());
		
		//BinarySerach 二分查找
		int i = Collections.binarySearch(list, 65);
		System.out.println(i);
		
		//copy复制
		List<Integer> list2 = new ArrayList<>();
		for(int j = 0; j < list.size(); j++) {
			list2.add(0);
		}
		Collections.copy(list2, list);
		System.out.println("list2:"+list2.toString());
		
		//reverse反转
		
		Collections.reverse(list);
		System.out.println("反转之后："+list.toString());
		
		//shuffle 打乱
		Collections.shuffle(list);
		System.out.println("打乱之后:"+list.toString());
		
		//补充：list转成数组
		System.out.println("--------list转成数组---------");
		Integer[] arr = list.toArray(new Integer[10]);
		System.out.println(arr.length);
		System.out.println(Arrays.toString(arr));
		
		//数组转成集合
		System.out.println("--------数组转成集合---------");
		String[] names = {"小米","苹果","三星","华为"};
		
		List<String> list3 = Arrays.asList(names);
		//集合是一个受限集合，不能进行添加和删除
		System.out.println(list3);
		
		//把基本类型转成集合时需要，需要修改为包装类型
		Integer[] nums = {100,200,300,400,500};
		List<Integer> list4 = Arrays.asList(nums);
		System.out.println(list4);
	}

}

运行结果：

排序前：[20, 3, 2, 65, 6, 234]
排序后：[2, 3, 6, 20, 65, 234]
4
list2:[2, 3, 6, 20, 65, 234]
反转之后：[234, 65, 20, 6, 3, 2]
打乱之后:[6, 20, 3, 2, 234, 65]
--------list转成数组---------
10
[6, 20, 3, 2, 234, 65, null, null, null, null]
--------数组转成集合---------
[小米, 苹果, 三星, 华为]
[100, 200, 300, 400, 500]

7.1 补充（使用到的实体类）

Person.java

/**
 * 人类
 * @author LYP
 *
 */
public class Person implements Comparable<Person>{
	private String name;
	private int age;
	public Person() {
		
	}
	public Person(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 "Person [name=" + name + ", age=" + age + "]";
	}
	
	@Override
	public int hashCode() {
		//(1)31是一个质数，减少散列冲突 （2）31提高执行效率  31*i = (i<<5)-i
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	//先按姓名比，再按年龄比
	@Override
	public int compareTo(Person o) {
		int n1 = this.getName().compareTo(o.getName());
		int n2 = this.age - o.getAge();
		return n1==0? n2:n1;
	}
	
	
//	@Override
//	public int hashCode() {
//		int n1 = this.name.hashCode();
//		int n2 = this.age;
//		return n1 + n2;
//	}
//	
//	@Override
//	public boolean equals(Object obj) {
//		if(this == obj) {
//			return true;
//		}
//		if(obj == null) {
//			return false;
//		}
//		if(obj instanceof Person) {
//			Person p = (Person)obj;
//			if(this.name.equals(p.getName())&&this.age == p.getAge()) {
//				return true;
//			}
//		}
//		return false;
//	}
	
}

Student.java

/**
 * 学生类
 * @author LYP
 *
 */
public class Student {
	private String name;
	private int age;
	public Student() {
		
	}
	public Student(String name, int age) {
		super();
		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 boolean equals(Object obj) {
		//1.判断是否是同一个对象
		if(this == obj) {
			return true;
		}
		//2.判断是否为空
		if(obj == null) {
			return false;
		}
		//3.判断是否是Student类型
		if(obj instanceof Student) {
			Student s = (Student)obj;
			//4.比较属性
			if(this.name.equals(s.getName())&&this.age == this.getAge()) {
				return true;
			}
		}
		//5.不满足条件返回false 
		return false;
	}
}

Student2.java

public class Student2 implements Comparable<Student2>{
	private String name;
	private int stuNo;
	
	public Student2() {
		// TODO Auto-generated constructor stub
	}

	public Student2(String name, int stuNo) {
		super();
		this.name = name;
		this.stuNo = stuNo;
	}

	public String getName() {
		return name;
	}

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

	public int getStuNo() {
		return stuNo;
	}

	public void setStuNo(int stuNo) {
		this.stuNo = stuNo;
	}

	@Override
	public String toString() {
		return "Student2 [name=" + name + ", stuNo=" + stuNo + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + stuNo;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student2 other = (Student2) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (stuNo != other.stuNo)
			return false;
		return true;
	}

	@Override
	public int compareTo(Student2 o) {
		int n1 = this.getStuNo() - o.getStuNo();
		return n1;
	}

	
	
	
	
}