Java中的容器类List\Set\Map

最新推荐文章于 2021-02-27 22:27:23 发布

yongganzhe02

最新推荐文章于 2021-02-27 22:27:23 发布

阅读量154

点赞数 2

分类专栏： Java 文章标签： java容器类

本文链接：https://blog.csdn.net/yongganzhe02/article/details/99309293

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

文章目录

一、容器类：
二、Collection工具类：
三、List接口：
- - 1.ArrayList：
  - 2.LinkedList：
四、Set接口：
- - 1.HashSet：
  - 2.TreeSet：
五、Map接口：

一、容器类：

java.util.Collection 接口
----->java.util.List 接口
---->java.util.ArrayList(Vector) 实现类
---->java.util.LinkedList 实现类
----->java.util.Set 接口 _不_能_放_重_复_对_象_，_是_否_重_复_由_e_q_u_a_s_方_法_决_定
----->java.util.HashSet 实现类
----->java.util.TreeSet 实现类
java.util.Map
----->java.util.HashMap
----->java.util.TreeMap
----->java.util.Hashtable

1.List接口：

List接口 共有三个实现类：
----->ArrayList
----->Vector
----->LinkedList

①ArrayList 内部是通过数组实现的，适合 随机查找和遍历，不适合插入和删除；
②Vector 和 ArrayList 大致相同，也是通过数组实现的，但它支持线程的同步
（即某一时刻只有一个线程能够写Vector，但实现同步需要很高的花费因此，访问它比访问ArrayList慢）。
③LinkedList 是用 链表结构 存储数据的，适合数据的 插入和删除，随机访问和遍历速度比较慢。
另外，他还提供了List接口中没有定义的方法，专门用于 操作表头和表尾元素，可当作堆栈、队列和双向队列使用。

2.Set接口：

Set就是数学中的集合，不能放入相同的对象。
HashSet和TreeSet都不是同步的，非线程安全；
Set接口 共有两个实现类：
----->HashSet
----->TreeSet

①HashSet类
加粗样式就是无序的集合，它不能保证元素的顺序。
HashSet 是 哈希表 实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束。
HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的String对象，hashcode是一样，所以不能放入。但是同一个类的对象可以放入不同的实例。

当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中 存储位置，这里的hashCode值一定要不相等，否则就会得出同一个存储位置，这是Set集合不允许的。
HashSet集合 判断两个元素相等 的标准是两个对象通过 equals方法 比较相等，并且两个对象的hashCode()方法返回值相等。
注意，如果要把一个对象放入HashSet中，重写该对象对应类的equals方法，也应该重写其hashCode()方法。其规则是如果两个对象通过equals方法比较返回true时，其hashCode也应该相同。另外，对象中用作equals比较标准的属性，都应该用来计算 hashCode的值。

②TreeSet类
TreeSet 可以确保 集合元素处于排序状态。
TreeSet 是 二差树 实现的,Treeset中的数据是自动排好序的，不允许放入null值。
TreeSet支持两种排序方式，自然排序和定制排序，其中自然排序为默认的排序方式。
因为要排序，所以TreeSet中要放的需要是同一类的对象。
TreeSet也是Set的子类，所以不能有重复元素。TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0。

自然排序
自然排序使用要排序元素的 CompareTo(Object obj) 方法来比较元素之间大小关系，然后将元素按照升序排列。
Java提供了一个 Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法 返回一个整数值，实现了该接口的对象就可以比较大小。
(obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是负数，则表明obj1小于obj2。)
如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0

定制排序
自然排序根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现
int compare(T o1,T o2) 方法。

3.Map接口：

	说明
HashMap	1.线程不安全；
	2.允许null value 和 null key，最多允许一条记录的键为空，允许多条记录的值为空；
	3.根据键的HashCode()值存储数据的位置；
	4.遍历时，取得的数据的顺序是完全随机的；
	5.在Map中插入、删除和定位元素，HashMap是较好的选择；
HashTable	1支持线程同步，线程安全；
	2.不允许有null value 和 null key；
	3.比Hashmap老，效率低下；
TreeMap	1.排序；
Properties	1.用于配置文件的定义和操作，使用频率比较高；
	2.键和值都是字符串；

二、Collection工具类：

package container;

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

public class CollectionsDemo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("aa");
		list.add("dd");
		list.add("ee");
		list.add("bb");
		list.add("cc");
		System.out.println(list);
		//反转
		Collections.reverse(list);
		System.out.println(list);
		
		System.out.println("=================");
		//排序
		Collections.sort(list);
		System.out.println(list);
	    System.out.println("============");
	    //排序2
	    Collections.sort(list, new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				// TODO Auto-generated method stub
				return o2.compareTo(o1);
			}
		});
	    System.out.println(list);
	    
	    ArrayList<Integer> list2 = new ArrayList<Integer>();
	    list2.add(10);
	    list2.add(1000);
	    list2.add(30);
	    //最大值
	    System.out.println(Collections.max(list2));
	}

}

三、List接口：

1.ArrayList：

package container;

import java.util.ArrayList;

public class ArrayListTest {

	public static void main(String[] args) {
			
			//一个没有泛型的ArrayList
				ArrayList list = new ArrayList();//可以容纳任何对象，Object
			
			//添加元素
				list.add(1100);//数字
				list.add('c');//字符
				list.add("zzj");//字符串
				
			//查看元素的个数
				System.out.println(list.size());//输出 3
			
			//直接打印集合对象
				System.out.println(list);//打印每个对象的toString，这里打印 [1100, c, zzj]
				
			//根据下标获取某个元素,打印对象的toString
				System.out.println(list.get(0));//输出 1100
				System.out.println(list.get(1));//输出 c
				System.out.println(list.get(2));//输出 zzj
			
				//System.out.println(list.get(8));//抛出数据下标越界异常 
			//java.lang.IndexOutOfBoundsException
			//原因是8这个位置上没有元素
				
				//list.add(5,"hello");//数组下标越界，规定只能连续放
			//前面放了3个元素，所以这个新元素只能放在0,1,2,3这个4个位置上

				//list.add(2,1100);//list集合中可以容纳重复的元素，这里并不是替换而是插入
			    //System.out.println(list);//输出 [1100, c, 1100, zzj]
			    
			//判断某个元素是否包含在集合中
				System.out.println(list.contains(1100));//true
				System.out.println(list.contains(1234));//false
			
			//移除元素
				System.out.println(list);//输出 [1100, c, zzj]
				System.out.println(list.remove(0));//返回的是被移除的对象 输出 1100
				System.out.println(list);//输出 [c, zzj]
				list.remove("zzj");
				System.out.println(list);//输出 [c]
				list.clear();//清空所有
				System.out.println(list);//输出 []

package container;
//实验对象Product类，用来说明泛型
public class Product {
	private String id;
	private String name;
	private double price;
	
	public Product(){}
	
	public Product(String id, String name, double price) {
		super();
		this.id = id;
		this.name = name;
		this.price = price;
	}


	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;
	}
	
	@Override
	//自动生成：equal()函数原本比较地址，
	//由于我们创建类时重写了equal()函数，使得id一样即相同，返回true
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Product other = (Product) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return id+"_"+name;
	}	
	
}

package container;

import java.util.ArrayList;

public class ArrayListDemo1 {
	public static void main(String[] args) {
	
		Product product1 = new Product("001","街舞课程",300);
		Product product2 = new Product("002","吉他课程",200);
		Product product3 = new Product("003","国画课程",400);
		Product product4 = new Product("004","围棋课程",500);
		Product productx = new Product("002","吉他课程",200);
		
		
		//一个没有泛型的ArrayList
		ArrayList list = new ArrayList();//可以容纳任何对象，Object
		
		//添加元素
		list.add(product1);
		list.add(product2);
		list.add(product3);
		
		//查看元素的个数
		System.out.println(list.size());//输出 3
		
		//直接打印集合对象
		System.out.println(list);//打印每个对象的toString，
		//这里打印 [001_街舞课程, 002_吉他课程, 003_国画课程]
		
		//根据下标获取某个元素,打印对象的toString
		Product product = (Product)list.get(0);
		System.out.println(product);//输出 001_街舞课程
		
			

	//判断某个元素是否包含在集合中
		System.out.println(list.contains(product1));//true
		System.out.println(list.contains(product4));//false


	//移除元素
		System.out.println(list);//输出 [001_街舞课程, 002_吉他课程, 003_国画课程]
		System.out.println(list.remove(0));//返回的是被移除的对象 输出 001_街舞课程
		System.out.println(list);//输出 [002_吉他课程, 003_国画课程]
		list.remove(product2);
		System.out.println(list);//输出 [003_国画课程]
		list.clear();//清空所有
		System.out.println(list);//输出 []

	//重点：equal()函数原本比较地址，由于我们创建类时重写了equal()函数，使得id一样即相同，返回true
		System.out.println(product2.equals(productx));//true

	}

}

package container;
//遍历
import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo1 {
	public static void main(String[] args) {
		Product product1 = new Product("001","街舞课程",300);
		Product product2 = new Product("002","吉他课程",200);
		Product product3 = new Product("003","国画课程",400);
				
		ArrayList list = new ArrayList();
		//添加元素
		list.add(product1);
		list.add(product2);
		list.add(product3);
		
	//遍历
		for(int i = 0; i < list.size();i++){
			Product pro = (Product)list.get(i);
			System.out.println(pro);
		}	
		
	//ArrayList类已经提供了迭代器 java.util.Iterator类
		Iterator itor = list.iterator();
		
		while(itor.hasNext()){
			Product pro = (Product)itor.next();
			System.out.println(pro);
		}
	
	//foreach遍历
		for(Object object : list){
			Product pro = (Product)object;
			System.out.println(pro);
		}

package container;

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo2 {
	public static void main(String[] args) {
		Product product1 = new Product("001","街舞课程",300);
		Product product2 = new Product("002","吉他课程",200);
		Product product3 = new Product("003","国画课程",400);
		
		
		/*泛型操作，指明products这个集合中只存放Product类型的实例
		 * 优点：在编译阶段  防止错误输入
		 * 实际操作中不需要做强制类型转换
		 */
		ArrayList<Product> products = new ArrayList<Product>();
	
		//添加元素
		//products.add("hello");编译不通过
		products.add(product1);
		products.add(product2);
		products.add(product3);
		
		
		//遍历，不需要做强制类型转换
		
		for(int i = 0; i < products.size();i++){
			System.out.println(products.get(i));
		}
		
	
	
		//迭代器遍历，不用做强制类型转换
		Iterator<Product> itor = products.iterator();
		while(itor.hasNext()){
			Product pro = itor.next();
			System.out.println(pro);
		}
		

		
		//forEach遍历，不用做强制类型转换
		for(Product product : products){
			System.out.println(product);
		}
	}

}

package container;
//通过反射绕过编译
import java.lang.reflect.Method;
import java.util.ArrayList;

public class ArrayListDemo3 {
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("hello");
		list.add("world");
		//list.add(100);报错
		System.out.println(list);
		
		
		
		for (String string : list) {
			System.out.println(string);
		}
		
		System.out.println("======================");
		
		
		
		
		
		//反射都是绕过编译操作，因为反射是拿编译完的字节码操作
		
		/*验证1：*/
		
		ArrayList list2 = new ArrayList();
		//结果是true说明类类型是一样的，那么也就是编译后是去泛型化的
		System.out.println(list.getClass()==list2.getClass());//true
		
		System.out.println(list.getClass()==ArrayList.class);//true
		
		
		
		/*验证2:用add方法的反射来进行操作*/
		try {
		    Method method = list.getClass().getMethod("add", new Class[]{Object.class});
		    method.invoke(list, new Object[]{100});
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(list.size());
		System.out.println(list);
		
		//但是在用forEach遍历就会有异常
		/*for(String str:list){
			System.out.println(str);
		}*/
		
	}

package container;
//Vector
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class VectorDemo {
	public static void main(String[] args) {
		
		Vector<String> v = new Vector<String>();
		v.add("hello");
		v.add("world");
		
		System.out.println(v.size());
		
		System.out.println(v);
		
		
		//遍历
		for(int i = 0; i < v.size();i++){
			System.out.println(v.get(i));
		}
		
		System.out.println("===============");
		
		for(String str:v){
			System.out.println(str);
		}
		
		
		System.out.println("================");
		
		
		Iterator<String> itor = v.iterator();
		while(itor.hasNext()){
			System.out.println(itor.next());
		}
		
		
		System.out.println("==================");
		
		////还有一种遍历方式老版本遗留的：
		
		
		Enumeration<String> e = v.elements();
		while(e.hasMoreElements()){
			System.out.println(e.nextElement());
		}
		
		
		System.out.println("===============");
		
		v.addElement("bye-bye");
		System.out.println(v);
		
	}

}

2.LinkedList：

package container;

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

public class LinkedListDemo1 {
	public static void main(String[] args) {
		LinkedList<String> list = new LinkedList<String>();
		
		list.add("xxx");
		list.add("aaa");
		list.add("hello");
		list.add("world");
		
		System.out.println(list.size());
		
		//遍历
		for (String string : list) {
			System.out.println(string);
		}
		
		System.out.println("==================");
		
		
		Iterator<String> itor = list.iterator();
		while(itor.hasNext()){
			System.out.println(itor.next());
		}
		
		
		System.out.println("===============");
		
		
		System.out.println(list.getFirst());
		
		System.out.println(list.getLast());
		
		System.out.println("=================");
		
		
		list.addFirst("start");
		list.addLast("end");
		

		System.out.println(list);
	}

}

java实现链表

package container;

public class LinkedListDemo2 {
	public static void main(String[] args) {
		Node1 node1 = new Node1("10");
		node1.next = new Node1("J");
		node1.next.next = new Node1("Q");
		node1.next.next.next = new Node1("K");
		node1.next.next.next.next = new Node1("A");
		System.out.println(node1);
	}
}
class Node1{
	Object value;
	Node1 next=null;
	public Node1(Object value){
		this.value = value;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return next==null ? value.toString() : (value+","+next);//拿字符串和对象相加，对象默认toString方法
	}
	
}

四、Set接口：

1.HashSet：

package container;
//实验类Student
public class Student {
	private String no;
	private String name;
	private int age;
	public Student(){}
	public Student(String no, String name, int age) {
		super();
		this.no = no;
		this.name = name;
		this.age = age;
	}
	public String getNo() {
		return no;
	}
	public void setNo(String no) {
		this.no = no;
	}
	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() {
		// TODO Auto-generated method stub
		return no+"_"+name;
	}
	
	
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((no == null) ? 0 : no.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;
		Student other = (Student) obj;
		if (no == null) {
			if (other.no != null)
				return false;
		} else if (!no.equals(other.no))
			return false;
		return true;
	}
	
}

package container;

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

public class HashSetDemo1 {
	public static void main(String[] args) {
		
		Student stu1 = new Student("001","zhangsan",22);
		Student stu2 = new Student("002", "lisi", 23);
		Student stu3 = new Student("003","wangwu",22);
		
		HashSet<Student> students = new HashSet<Student>();
		
		students.add(stu1);
		students.add(stu2);
		students.add(stu3);
		
		System.out.println(students.size());
		
		System.out.println(students);
		
		
		System.out.println("================");
		
		
		for (Student student : students) {
			System.out.println(student);
		}
		
		System.out.println("===============");
		
		
		Iterator<Student> itor = students.iterator();
		while(itor.hasNext()){
			System.out.println(itor.next());
		}
		
		
		System.out.println("=================");
		
		
		//students.add(stu3);加入重复元素会自动过滤加不进去
		
		
		System.out.println(students.size());//还是3
		
		
		
		
		
		Student stu4 = new Student("003","wangwu",22);
		System.out.println(stu3.equals(stu4));//equals没重写比较地址就是false,这里true
		
		
		
		/*重复元素到底如何去定义
		 * stu3/stu4创建对象时是两个对象
		 * 但在实际应用中是同一个学员
		 * 在这个场景中必须用唯一标识对象的属性来重写
		 * equals和hashCode方法
		 * hashCode方法是一种散列算法，现在不用关心如何去写
		 * 它和HashSet中数据的存放有直接关系
		 */
		
		
		
		students.add(stu4);
		System.out.println(students.size());//还是3
	}

}

package container;

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

public class HashSetDemo2 {
	public static void main(String[] args) {
		Student stu1 = new Student("001","zhangsan",22);
		Student stu2 = new Student("002", "lisi", 23);
		Student stu3 = new Student("003","wangwu",22);
		
		
		HashSet<Student> students = new HashSet<Student>();
		
		
		students.add(stu1);
		students.add(stu2);
		students.add(stu3);
		
	    System.out.println(students.size());
	    
	    
	    
	    
	    
	    stu1.setNo("000x");//修改该属性后，对象移除不了
	    
	    
	    students.remove(stu1);
	    System.out.println(students.size());
	   
	    
	    
	    /*
	     * HashSet存放元素的时候元素的位置
	     * 是和对象hashCode算法得到的值相关的。
	     * 
	     * 那么去查找元素时，也要根据这个算法的值
	     * 然后找到相关位置，移除元素，
	     * 如果没有元素存在，remove方法返回false
	     * 
	     * 如果跟该算法相关的属性值在放入容器后被修改了，
	     * 意味着hashCode算法得到的值和之前放入容器
	     * 时不一样了，找对象的位置就发生了改变，从而
	     * 找不到之前的对象，导致元素不能移除，
	     * 久而久之会产生内存泄露
	     */
	}

}

2.TreeSet：

自然排序：

package container;
//实验对象User类，实现Comparable接口，并重写接口中的compareTo方法
public class User implements Comparable<User>{
	private String name;
	private String pass;
	private int age;
	public User(){}
	public User(String name, String pass, int age) {
		super();
		this.name = name;
		this.pass = pass;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPass() {
		return pass;
	}
	public void setPass(String pass) {
		this.pass = pass;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [name=" + name + "age  " + age +  "  ]";
	}
	
	
	
	//自然排序的方法compareTo，重写compareTo方法
	@Override
	public int compareTo(User o) {
		if(!this.name.equals(o.name))
			return this.name.compareTo(o.name);
		else
			return this.age-o.age;
		//return 0;
	}
	
}

package container;
//TreeSet类
import java.util.TreeSet;

public class TreeSetDemo {
	public static void main(String[] args) {
		
		User user1 = new User("zhangsan", "1234", 20);
		User user2 = new User("lisi","3456",22);
		User user3 = new User("zhangsa","1234",30);
		
		
		TreeSet<User> ts = new TreeSet<User>();
		
		ts.add(user1);
		ts.add(user2);
		ts.add(user3);
		
		System.out.println(ts);
	}

}

定制排序：

package container;
//实验对象User1类，实现Comparator接口，并重写compare()方法（用匿名内部类实现）
public class User1{
	private String name;
	private String pass;
	private int age;
	public User1(){}
	public User1(String name, String pass, int age) {
		super();
		this.name = name;
		this.pass = pass;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPass() {
		return pass;
	}
	public void setPass(String pass) {
		this.pass = pass;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [name=" + name + "]";
	}
}

package container;
//TreeSet
import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo2 {
	public static void main(String[] args) {
		
		User1 user1 = new User1("zhangsan","12343",30);
		User1 user2 = new User1("lisi","23344",22);
		User1 user3 = new User1("wangwu","1233444",33);
		
			
		//匿名内部类
		TreeSet<User1> ts1 = new TreeSet<User1>(new Comparator<User1>() {

			@Override
			public int compare(User1 o1, User1 o2) {
				return o2.getName().compareTo(o1.getName());
			}
		});
		ts1.add(user1);
		ts1.add(user2);
		ts1.add(user3);
		System.out.println(ts1);



		TreeSet<User1> ts = new TreeSet<User1>(new MyComparator());
		ts.add(user1);
		ts.add(user2);
		ts.add(user3);
		System.out.println(ts);
		
		
	}
	

	
	static class MyComparator implements Comparator<User1>{

		@Override
		public int compare(User1 o1, User1 o2) {
			// TODO Auto-generated method stub
			return o1.getName().compareTo(o2.getName());
			
		}
		
	}

}

package container;
//String类比较特殊
import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo3 {
	public static void main(String[] args) {
		
//		TreeSet<String> ts = new TreeSet<String>(new Comparator<String>() {
////倒序
//			@Override
//			public int compare(String o1, String o2) {	
//				return o2.compareTo(o1);
//			}
//		});
		
		//String类已经重写了Compare方法
		TreeSet<String> ts = new TreeSet<String>(); 
		ts.add("hello");
		ts.add("world");
		ts.add("zhangsan");
		ts.add("lisi");
		ts.add("wangwu");
		System.out.println(ts);
	}

}

五、Map接口：

1.HashMap：

package container;
//实验类 User2
public class User2 {
	private String id;
	private String name;
	private int age;
	private String pass;
	public User2(){}
	public User2(String id, String name, int age, String pass) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.pass = pass;
	}
	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 int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getPass() {
		return pass;
	}
	public void setPass(String pass) {
		this.pass = pass;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return name;
	}
}

package container;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapDemo1 {
	public static void main(String[] args) {
		
		User2 u1 = new User2("0001", "zhangsan", 20, "1234");
		User2 u2 = new User2("0002","lisi",21,"12345");
		User2 u3 = new User2("0003","wangwu",20,"123456");
		
		HashMap hm = new HashMap();
		
		hm.put(u1.getId(),u1);
		hm.put(u2.getId(), u2);
		hm.put(u3.getId(),u3);
		
		
		//键值对的个数
		System.out.println(hm.size());//3
		
		//直接打印Map对象会打印  key的toString=value的toString
		System.out.println(hm);
		
		
		//获取 get(key)得到value
		
		//key value都是Object  ,注意类型转换 
		
		User2 user = (User2)hm.get("0001");
		System.out.println(user);
		
		
		
		//是否包含某个key
		System.out.println(hm.containsKey("0002"));
		//containsValue
		System.out.println(hm.containsValue(u2));
		
		
		
		
		/*遍历方式1：把Map中所有的key都放入了Set集合中
		 * 然后遍历Set集合，得到key,通过key获取value
		 */
		
		Set set = hm.keySet();
		
		for(Object object : set){
			String key = (String)object;
			User2 u = (User2)hm.get(key);
			System.out.println(key+"="+u);
		}
		
		
		
		
		System.out.println("================");
		
		
		
		
		/*
		 * 遍历方式2
		 *  放入HashMap集合中的key,value其实都会被包装成
		 *  Map.Entry这个内部类的属性  
		 *  有一个键值对就存在一个Map.Entry的实例对象
		 *  通过entrySet()方法就可以把这些实例对象都放入Set集合中
		 *  遍历Set获取每个对象
		 */
		
		Set set1 = hm.entrySet();
		for(Object object:set1){
			
			Map.Entry me = (Map.Entry)object;
			System.out.println(me.getKey()+"="+me.getValue());//获取属性的getter和setter
		}
	}

}

用泛型

package container;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapDemo2 {
	public static void main(String[] args) {
		
		User2 u1 = new User2("0001", "zhangsan", 20, "1234");
		User2 u2 = new User2("0002","lisi",21,"12345");
		User2 u3 = new User2("0003","wangwu",20,"123456");
		
		
		HashMap<String, User2> users = new HashMap<String,User2>();
		users.put(u1.getId(),u1);
		users.put(u2.getId(), u2);
		users.put(u3.getId(), u3);
		
		
		Set<String> set = users.keySet();
		
		
		for(String key : set){
			System.out.println(key+"="+users.get(key));
		}
		
		
		
		System.out.println("===================");
		
		
		
		
		Set<Map.Entry<String, User2>> set1 = users.entrySet();
		
		for(Map.Entry<String, User2> me : set1){
			System.out.println(me.getKey()+"="+me.getValue());
		}
		
		
		
		
	}

}

案例1：

package container;

import java.util.HashMap;

public class HashMapDemo3 {
	public static void main(String[] args) {
		HashMap<String, Integer> hm = new HashMap<String,Integer>();
		hm.put("x", 10);
		hm.put("y", 20);
		
		/*key相同 会覆盖之前的value 
		 * key如何才能相同？
		 * key所属的类注意equals方法和hashCode方法的实现
		*/
		
		hm.put("x", 30);
		
		System.out.println(hm);
		//x=10被x=30覆盖
		
		System.out.println("========================");
		
		
		
		
		
		
		
		//计算每个字符出现的次数
		String s = "abcdefghijkabchdieukkscsserdaaxayh";
		
		/*
		 * 思路：拿到每个字符，作为key放入HashMap中如果
		 * 如果map中不存在 那么put(key,1)
		 * 如果已经存在  那么put(key,value+1);
		 */
		
		
		HashMap<String, Integer> hm1 = new HashMap<String,Integer>();
		
		for(int i = 0; i < s.length();i++){
			
			String str = s.substring(i,i+1);//去除这个字符
			
			if(hm1.containsKey(str)){//包含了
				
				hm1.put(str, hm1.get(str)+1);
			}else{
				//不包含
				hm1.put(str, 1);
			}
		}
		System.out.println(hm1);
		
	}

}

案例2：

package container;

import java.util.HashMap;
import java.util.TreeSet;

public class HashMapDemo4 {
	public static void main(String[] args) {
		
		
		/*对如下字符串进行计数，看出现的次数
		 * 输出时要求按照  次数降序排序  ，如果次数相同
		 * 按照字母升序排序
		 * 
		 * 思路：通过HashMap集合就可以实现计算次数的操作
		 * 如果要进行排序我们可以采用TreeSet集合
		 * 并且是根据放入TreeSet中的对象的属性进行排序的
		 * 我们可以抽取出一个类完成这个工作
		*/
		
		
		String s = "abcdefghijkabchdieukkscsserdaaxayh";
		HashMap<String, Integer> hm1 = new HashMap<String,Integer>();
		for(int i = 0; i < s.length();i++){
			String str = s.substring(i,i+1);
			if(hm1.containsKey(str)){
				hm1.put(str, hm1.get(str)+1);
			}else{
				hm1.put(str, 1);
			}
		}
		
		
		//System.out.println(hm1);
		/*
		 * 遍历HashMap集合，然后把每一个key/value都包装
		 * 成T对象的实例放入TreeSet集合，就完成了排序
		 */
		
		
		
		TreeSet<T> ts = new TreeSet<T>();
		//遍历
		for(String key : hm1.keySet()){
			T t = new T(key,hm1.get(key));
			ts.add(t);
		}
		System.out.println(ts);
	}
}



class T implements Comparable<T>{
	private String name;
	private int count;
	
	public T(String name, int count) {
		super();
		this.name = name;
		this.count = count;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getCount() {
		return count;
	}
	public void setCount(int count) {
		this.count = count;
	}
	@Override
	public String toString() {
		return name+"出现的次数是:"+count;
	}
	
	
	@Override
	public int compareTo(T o) {
		if(this.count!=o.count)
			return o.count-this.count;
		return this.name.compareTo(o.name);
	}
	
}

2.TreeMap：

package container;
//实验用类User
public class User implements Comparable<User>{
	private String name;
	private String pass;
	private int age;
	public User(){}
	public User(String name, String pass, int age) {
		super();
		this.name = name;
		this.pass = pass;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPass() {
		return pass;
	}
	public void setPass(String pass) {
		this.pass = pass;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [name=" + name + "age  " + age +  "  ]";
	}
	
	
	
	
	@Override
	public int compareTo(User o) {
		if(!this.name.equals(o.name))
			return this.name.compareTo(o.name);
//		else
//			return this.age-o.age;
		return 0;
	}
	
}

package container;

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMapDemo {
	public static void main(String[] args) {
	    TreeMap<User, Integer> users = new TreeMap<User,Integer>();
		User user1 = new User("zhangsan", "1234", 20);
		User user2 = new User("lisi","3456",22);
		User user3 = new User("wangwu","1234",20);
		users.put(user1, 1);
		users.put(user2, 2);
		users.put(user3, 3);
		
		for(User user : users.keySet()){
			System.out.println(user+"="+users.get(user));
		}
		
		TreeMap<User, Integer> users1 = 
				  new TreeMap<User,Integer>(new Comparator<User>() {

					@Override
					public int compare(User o1, User o2) {
						// TODO Auto-generated method stub
						return o1.getName().compareTo(o2.getName());
					}
				 });
		users1.put(user1, 1);
		users1.put(user2, 2);
		users1.put(user3, 3);
		System.out.println(users1);
	}

}

3.HashTable：

package container;

import java.util.HashMap;
import java.util.Hashtable;

public class HashtableDemo {
	public static void main(String[] args) {
		Hashtable<String, String> hs = new Hashtable<String,String>();
		hs.put("aa", "hello");
		hs.put("bb", "world");
		System.out.println(hs);
		for(String key:hs.keySet()){
			System.out.println(key+"="+hs.get(key));
		}
		
		HashMap hm = new HashMap();
		hm.put(null, null);
		System.out.println(hm);
		hs.put(null, null);
	}

}

4.Properties：

yongganzhe02

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中的容器类List\Set\Map

一、容器类java.util.Collection接口------>java.util.List接口--------->java.util.ArrayList(Vector)实现类--------->java.util.LinkedList实现类------>java.util.Set接口集中中不能放重复对象是否重复由equals方法决定---------&...
复制链接

扫一扫

专栏目录