JAVA基础课程(第二十天)_rm collection-CSDN博客

本文链接：https://blog.csdn.net/weixin_35133235/article/details/106032752

JAVA基础课程

第二十天集合：Collection和Map的简单使用

源码分析会在以后的章节中分析

Java集合框架概述

（1）集合、数组都是对多个数据进行存储操作的结构，简称Java容器（这里的存储指的是内存层面的存储）

（2）数组存储

优点：

①一旦初始化，其长度确定

②数组一旦定义好，其元素的类型也就确定，我们也就只能操作指定的类型的数据

缺点：

①一旦初始化，长度不可修改

②数组提供的方法有限，对数据操作不太方便，并且效率不高

③获取数组中时间元素的个数需求，数组没有指定的方法或属性

④数组存储是有序，可重复，不可重复的需求不可满足

（3）Java集合可分为Collection和Map两种体系

Collection接口：单列数据，定义了存取一组对象的方法集合

List：元素有序，可重复的集合(ArrayList，LinkedList，Vector)

Set：元素无序，不可重复的集合 (HashSet,LinkedHashSet,TreeSet)

Map接口：双列数据，保存具有映射关系的“key-value”的集合（HashMap,LindedHashMap,TreeMap,HashTable,Properties）

Collection接口方法

以下测试类覆盖几乎所有Collection接口的方法

package com.test.course.collectiontest;

import org.junit.Test;

import java.util.*;

/**
 * 〈Collection的基本方法〉
 *
 * @author PitterWang
 * @create 2020/5/8
 * @since 1.0.0
 */
public class CollectionTest {

	@Test
	public void test(){
		Collection collection = new ArrayList();
		//Collection add()方法
		System.out.println("*****************************add()方法测试");

		collection.add("111");
		collection.add(123);
		collection.add(new String("DD"));
		collection.add(false);

		collection.add(new Persion(1,"TT"));
		System.out.println(collection);
		System.out.println("*****************************contains(Object o)方法测试");
		//Collection 的contains(Object o) 判断当前集合是否包含o
		//判断是会调用o的equals()方法，
		System.out.println(collection.contains(123));
		System.out.println(collection.contains(new String("DD")));
		System.out.println(collection.contains(new Persion(1,"TT"))); //如果不重写equals方法，那就是比较的地址，是false

		System.out.println("*****************************remove()方法测试");
		collection.remove(new Persion(1,"TT"));
		System.out.println(collection);

		System.out.println("*****************************removeAll()方法测试");
		Collection rmCollection = Arrays.asList("111",123);
		collection.removeAll(rmCollection);
		System.out.println(collection);
		/***
		 * retainAll不太好理解
		 * list1与list2做交集，结果集与list2做比较，如果相同返回true，否则返回false
		 * list1与list2做交集，结果集赋值给list1，如果list1被改变返回true，否则返回false
		 */
		System.out.println("*****************************retainAll()方法测试");
		Collection collection1 = new ArrayList();
		collection1.add(1);
		collection1.add(2);
		collection1.add(3);

		Collection collection2 = new ArrayList();
		collection2.add(3);
		collection2.add(5);
		collection2.add(4);
		System.out.println("collection1中的元素：" + collection1);
		System.out.println("collection2中的元素：" + collection2);


		System.out.println("交集的元素：" + collection1.retainAll(collection2));
		System.out.println("collection1中的元素：" + collection1);
		System.out.println("collection2中的元素：" + collection2);

		System.out.println("*****************************equals()方法测试--比较两个集合是否一样，顺序一致");

		Collection collection3 = new ArrayList();
		collection3.add(1);
		collection3.add(2);
		collection3.add(3);

		Collection collection4 = new ArrayList();
		collection4.add(3);
		collection4.add(2);
		collection4.add(1);
		System.out.println("collection3中的元素：" + collection3);
		System.out.println("collection4中的元素：" + collection4);

		System.out.println(collection3.equals(collection4));
		System.out.println("collection3中的元素：" + collection3);
		System.out.println("collection4中的元素：" + collection4);
		
		System.out.println("*****************************hashCode()方法:获得当前对象的哈希值");
		System.out.println(collection4.hashCode());

		System.out.println("*****************************toArray()方法:集合转数组");
		Collection collection5 = new ArrayList();
		collection5.add(1);
		collection5.add(2);
		collection5.add(3);
		Object[] objects = collection5.toArray();

		System.out.println("*****************************Arrays.asList()方法:数组转集合");
		List<String> s = Arrays.asList(new String[]{"AA", "BB"});

		System.out.println("*****************************isEmpty()方法:是否为空");
		System.out.println(collection.isEmpty());
		System.out.println("*****************************size()方法:collection的长度");
		System.out.println(collection.size());

		System.out.println("*****************************iterator()方法:迭代器");
		Iterator iterator = collection5.iterator();
		while (iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}
}

class Persion {
	private int id;
	private String name;

	public Persion(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	@Override
	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;
		Persion persion = (Persion) o;
		return id == persion.id &&
				Objects.equals(name, persion.name);
	}

	@Override
	public int hashCode() {
		return Objects.hash(id, name);
	}
}

Itrator迭代器

（1）Iterator对象被称为迭代器。主要遍历Collection集合中的元素

（2）GOF给迭代器模式的定义为：提供以一种方法访问一个容器对象的各个元素，而又不需要暴露该对象的内部细节。

（3）集合对象每次调用Iterator()方法得到一个全新的迭代器对象

（4）remove（），可以删除集合中的元素

		Collection collection = new ArrayList();
		collection.add("111");
		collection.add("222");
		collection.add("333");


		Iterator iterator = collection.iterator();

		System.out.println("***********************************前************************************");
		while (iterator.hasNext()){
			//next();①指针下移，②将下移以后集合位置上的元素返回
			String objects = (String) iterator.next();
			if(objects.equals("111")){
				iterator.remove();
			}
			System.out.println("objects = " + objects);

		}
		System.out.println("***********************************remove************************************");

		//iterator默认游标在集合的第一个元素之前
		//hasNext();判断是否还有下一个元素
		Iterator iterator1 = collection.iterator();
		while (iterator1.hasNext()){
			//next();①指针下移，②将下移以后集合位置上的元素返回
			String objects = (String) iterator1.next();
			if(objects.equals("111")){
				iterator1.remove();
			}
			System.out.println("objects = " + objects);

		}

foreach遍历集合

（1）遍历不需要获取集合或数组长度，无需要索引访问元素

（2）底层用的是iterator完成操作

（3）foreach可以遍历数组

	Collection collection = new ArrayList();
		collection.add("111");
		collection.add("222");
		collection.add("333");

		for (Object o : collection) {
			System.out.println(o);
		}

Collection子接口一：List：元素有序，可重复

（1）基本说明

ArrayList：作为list的主要实现类，线程不安全的，效率高，底层使用Object[] elementData存储

LinkedList:对于频繁插入、删除操作，使用效率比ArrayList高：底层使用双向链表存储

Vector:List最古老的实现类，线程安全的，效率低，底层使用Object[] elementData存储

对ArrayList，LinkedList，Vector源码分析以后分析~~~

（2）ArrayList常用方法

增：add(Obj obj)

删：remove（int index）/remove（Object obj）

改：set(int index,Object ele)

查：get(int index)

插入：add(int index,Object ele);

长度：size

遍历：Iterator,for,foreach

（3）代码

package com.test.course.collectiontest;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
 * 〈List〉
 * @author PitterWang
 * @create 2020/5/10
 * @since 1.0.0
 */
public class ListTest {
	@Test
	public void test(){
		System.out.println("***********add()方法，Iterator遍历**********");
		ArrayList list = new ArrayList();
		list.add("1111");
		list.add("2222");
		list.add(1,"3333");
		Iterator iterator = list.iterator();
		while (iterator.hasNext()){
			System.out.println(iterator.next());
		}
		System.out.println("***********remove()方法，foreach遍历**********");
		list.remove(1);
		list.remove("1111");
		for (Object o : list) {
			System.out.println(o);
		}
		System.out.println("***********set()方法**********");
		list.set(0,"44444444444");
		for (Object o : list) {
			System.out.println(o);
		}
		System.out.println("***********get()方法,size()方法**********");
		for (int i = 0;i<list.size();i++){
			System.out.println(list.get(i));
		}
	}
}

Collection子接口二：Set：不允许包含相同的元素，并且是无序的。

（1）基本说明

HashSet：Set接口的主要实现类：线程不安全的，可以存储null

LinkedHashSet：HashSet的子类，维护数据时，使用hashCode觉得存储位置，但是他同时使用双向链表维护元素次序，所以遍历的时候，可以按照插入的顺序遍历，但是底层存储还时无序的。

TreeSet：可以按照添加对象的指定属性进行排序。底层实现了红黑树结构的存储数据（自然排序和定制排序）

（2）理解：

①Set接口中没有定义新的方法，都用的Collection中声明的方法

②向Set中添加的数据，其所在的类一定要重写equals()方法和hashCode()方法，以实现对象相等规则，相等的对象必须具有相同的hashCode。

（3）代码

package com.test.course.collectiontest;

import org.junit.Test;

import java.util.*;

/**
 * 〈Set〉
 * @author PitterWang
 * @create 2020/5/10
 * @since 1.0.0
 */
public class SetTest {
	@Test
	public void test1(){
		//自定义排序
		TreeSet treeSet = new TreeSet(new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				if(o1 instanceof String && o2 instanceof String){
					return -((String) o1).compareTo((String) o2);
				}
				throw new RuntimeException("异常");
			}
		});
		treeSet.add("a");
		treeSet.add("b");
		treeSet.add("c");
		System.out.println(treeSet);
		TreeSet treeSetDog = new TreeSet();
		treeSetDog.add(new Dog(3,"GG"));
		treeSetDog.add(new Dog(1,"TT"));
		treeSetDog.add(new Dog(2,"FF"));
		System.out.println(treeSetDog);

	}
	
	@Test
	public void test(){
		Set set = new HashSet();
		set.add("123");
		set.add("234");
		set.add("456");
		set.add("123");
		/**
		 * 向Set中添加的数据，
		 * 其所在的类一定要重写equals()方法和hashCode()方法，
		 * 以实现对象相等规则，相等的对象必须具有相同的hashCode。
		 */
		set.add(new String("234"));
		set.add(new Per(1,"TT"));
		set.add(new Per(1,"TT"));
		set.add(new Dog(1,"TT"));
		set.add(new Dog(1,"TT"));
		System.out.println(set);
	}
}

class Dog implements Comparable{
	int id;
	String name;

	public Dog(int id, String name) {
		this.id = id;
		this.name = name;
	}

	@Override
	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;
		Dog dog = (Dog) o;
		return id == dog.id &&
				Objects.equals(name, dog.name);
	}

	@Override
	public int hashCode() {
		return Objects.hash(id, name);
	}

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



	@Override
	public int compareTo(Object o) {
		if(o instanceof Dog){
			Dog dog = (Dog)o;

			if(this.id > dog.id){
				return 1;
			}else if(this.id < dog.id){
				return -1;
			}else{
				return 0;
			}
		}

		throw new RuntimeException("异常");
	}

}
class Per{
	int id;
	String name;

	public Per(int id, String name) {
		this.id = id;
		this.name = name;
	}

	@Override
	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;
		Per per = (Per) o;
		return id == per.id &&
				Objects.equals(name, per.name);
	}

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

Map接口

（1）基本说明

Map:双列数据，存储key-value对的数据

HashMap：作为Map的主要实现类，线程不安全的，但是效率高。可以存储null的key，value。

LinkedHashMap：HashMap的子类，保证遍历map元素时，可以按照添加的顺序实现遍历。（在原有的HashMap的底层实现基础上，又添加了一对指针，指向前一个和后一个数据）

TreeMap：保证添加的key-value对进行排序，实现排序遍历，考虑key的自然排序和定制排序

Hashtable：古老的实现类，线程安全，效率低，不能存储null的key，value。

Properties：用来处理配置文件，Key和value都是String

（2）理解

Map中的key：无序，不可重复，使用Set存储所有的key

Map中的value：无序，可重复，使用Collection存储所有的value

一个键值对，构成一个Entry对象(Node)

（3）Map中自定义方法

增：V put(K key, V value);

void putAll(Map<? extends K, ? extends V> m);

删：remove（Object obj）,clear()

改：V put(K key, V value);

查：V get(Object key);

boolean containsKey(Object key); 是否包含指定的key

containsValue(Object value);是否包含指定的value

长度：int size();

是否为空：isEmpty()

判断当前map是否和o是否相等：boolean equals(Object o);

元视图操作方法：

Set keySet(); 返回key构成的Set集合

Collection values();返回value构成的Collection集合

Set<Map.Entry<K, V>> entrySet(); 返回key-value构成的Set集合

（4）代码

package com.test.course.compartest;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
 * 〈Map〉
 * @author PitterWang
 * @create 2020/5/10
 * @since 1.0.0
 */
public class MapTest {

	@Test
	public void test(){
		System.out.println("**********put***********");
		Map map = new HashMap();
		map.put("1","11");
		map.put("2","11");
		map.put("3","11");
		map.put("4","11");
		System.out.println("**********get***********");
		System.out.println(map.get("1"));
		System.out.println("**********entrySet***********");
		Set set = map.entrySet();
		for (Object o : set) {
			Map.Entry en = (Map.Entry) o;
			System.out.println("key = " + en.getKey() + "value = " + en.getValue());
		}
	}
}

package com.test.course.compartest;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

/**
 * 〈Properties〉
 * @author PitterWang
 * @create 2020/5/10
 * @since 1.0.0
 */
public class PropertiesTest {

	@Test
	public void test(){

		FileInputStream fis = null;

		Properties properties = new Properties();
		try {
			fis = new FileInputStream("test.propertise");
			properties.load(fis);
			String name = properties.getProperty("name");
			String word = properties.getProperty("word");
			System.out.println(name);
			System.out.println(word);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}
}

test.propertise
name=123
word=234

Collections工具类

（1）Collections是操作Set，List，Map等集合的工具类，Arrays是操作数组的工具类

（2）提供了一系列静态方法对集合元素进行排序，查询，修改等操作，还提供对集合对象不可变，对集合对象实现同步控制等方法

package com.test.course.compartest;

import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 〈Collections〉<br>
 * @author PitterWang
 * @create 2020/5/10
 * @since 1.0.0
 */
public class CollectionsTest {

	@Test
	public void test(){
		List list = new ArrayList();
		list.add("1111");
		list.add("2222");
		list.add(1,"3333");
		Object[] obj = new Object[list.size()];
		List newlist = Arrays.asList(obj);
		Collections.copy(newlist,list);
		System.out.println(newlist);

		/**
		 * 线程安全的
		 */
		List list1 = Collections.synchronizedList(list);
	}
}