javaSE-day06--HashMap基本用法、HashSet基本用法、iterator迭代器、增强for循环

HashMap基本用法

package day06;

import java.util.HashMap;

public class HashMapDemo {
	public static void main(String[] args) {
		HashMap<String,String> map1 = new HashMap<>();
		
		//向HashMap中添加数据  
		//如果添加的key相同则会被覆盖
		map1.put("1","长沙" );
		map1.put("1","北京" );
		map1.put("2","天津");
		map1.put("3","上海");
		map1.put("4","广州");
		map1.put("5","深圳");
		map1.put("6","岳阳");
		
		//从HashMap中取出数据
		String a = map1.get("1");
		System.out.println(a);
		
		//从HashMap中删除数据,可以 用字符串变量来接受删除的内容
		String aa = map1.remove("2");
		System.out.println(aa);
		
		//获取HashMap的长度
		int size = map1.size();
		System.out.println(size);
		
		//判断数据是否在HashMap中 
		//使用HashMap的contains功能判断指定的key是否存在
		boolean c = map1.containsKey("2");
		System.out.println(c);
		
		// HashMap的遍历
		Set<String> keySet = map1.keySet();
		for (String a1 : keySet) {
			System.out.println(a1);
		}
	}
}

总结：

• HashMap在生成对象时需要声明key和数据的数据类型，例如<Integer,String>。在添加数据的时候同样需要输入key和数据。
• 优点：使用HashMap只需要有key就可以取到需要的值。
• HashSet中有一个方法keyset,返回map中的key。存储到Set集合对象中：keySet，再通过增强for循环来遍历。

HashSet基本用法

package day06;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
/*
 * HashSet也是一种集合数据类型
 * 可以放入多个值
 */
public class HashSetDemo {
	public static void main(String[] args) {
		HashSet<String> set = new HashSet<>();
		//向HashSet中添加数据
		set.add("北京");
		set.add("上海");
		set.add("广州");
		set.add("天津");
		set.add("深圳");
		
		//获取HashSet的长度
		int a = set.size();
		System.out.println("HashSet长度："+a);
		
		//删除HashSet中的数据，返回一个boolean值
		System.out.println("是否删除："+set.remove("北京"));
		//遍历HashSet
		Iterator<String> iterator = set.iterator();
		//iterator.hashNext();判断set中是否还有数据，返回一个boolean数据类型。
		//iterator.next();读取值，并将索引向下移动一位。
		System.out.println("遍历HashSet：");
		while(iterator.hasNext()) {
			String xx = iterator.next();
			System.out.println(xx);
		}
		
		//增强for循环--将迭代器 封装为增强for循环
		System.out.println("增强for循环遍历HashSet:");
		for(String temp:set) {
			System.out.println(temp);
		}
		
		System.out.println("增强for循环可以遍历数组:");
		int[] aa = new int[] {8,9,10,11};
		for(int ab:aa) {
			System.out.println(ab);
		}
		
		System.out.println("增强for循环可以遍历ArrayList:");
		ArrayList<Integer> a1 = new ArrayList<Integer>();
		a1.add(100);
		a1.add(200);
		a1.add(300);
		for(int ab:a1) {
			System.out.println(ab);
		}
		
	}
}

总结：

• HashSet也是一种集合数据类型。它就像一个黑盒在里边存储没有顺序。
• 遍历没有顺序的集合，需要用到iterator迭代器。iterator.hashNext();判断set中是否还有数据，返回一个boolean数据类型。iterator.next();读取值，并将索引向下移动一位。
• 增强for循环将迭代器封装，使遍历更加便捷。同样可以应用于数组和ArrayList的遍历。
  for(返回类型 名字:遍历的集合)

练习

几种集合数据类型的使用

练习要求：
1、定义一个User类，包含属性： id,name,password,phone,age,薪水 要求：所有属性为private

2、写一个程序,用题1的User类，构造4个user对象

3、将题2中的4个user对象存入一个数组，然后再存入一个Arraylist，再存入一个HashSet，再存入一个HashMap

4、将题3中的list 、 set、 map 分别遍历打印所有user数据

5、分别从题3的list中找出年龄最大的user对象，从set中找出薪水最高的user对象，从map中找出age最小的user对象

6、定义一个Product类，包含以下属性 pId pName price num

写一个程序，造数据： 造5个商品对象，id分别为 “1”,“2”,“3”,“4”,“5” 然后造3个用户对象， 然后模拟生成购物车

张三，产品1：2个，产品3:4个，产品5:1 李四，产品2：3个，产品4:1个，产品3:1

然后写一个工具方法，传入一个购物车，和一个用户的名字，就能返回这个用户的购物车中的商品列表

package day06;

public class User {
	private String Id;
	private String name;
	private String password;
	private String phone;
	private int age;
	private double salary;

	public User() {

	}

	public User(String id, String name, String password, String phone, int age, double salary) {
		Id = id;
		this.name = name;
		this.password = password;
		this.phone = phone;
		this.age = age;
		this.salary = salary;
	}

	public String getId() {
		return Id;
	}

	public void setId(String id) {
		Id = id;
	}

	public String getName() {
		return name;
	}

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

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public String toString() {
		return Id+","+name+","+password+","+phone+","+age+","+salary;
	}
}





package day06;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;

public class UserTest {
	public static void main(String[] args) {
		User user1 = new User("01", "张三", "123456", "110", 18, 1800);
		User user2 = new User("02", "李四", "124789", "119", 20, 1900);
		User user3 = new User("03", "赵五", "777777", "120", 22, 2000);
		User user4 = new User("04", "王六", "444444", "911", 23, 1600);
		// 放入数组
		User[] user = new User[] { user1, user2, user3, user4 };
		// 放入list
		ArrayList<User> arrayList = new ArrayList<>();
		arrayList.add(user1);
		arrayList.add(user2);
		arrayList.add(user3);
		arrayList.add(user4);
		// 放入HashSet
		HashSet<User> hashSet = new HashSet<>();
		hashSet.add(user1);
		hashSet.add(user2);
		hashSet.add(user3);
		hashSet.add(user4);
		// 放入HashMap
		HashMap<String, User> hashMap = new HashMap<>();
		hashMap.put(user1.getId(), user1);
		hashMap.put(user2.getId(), user2);
		hashMap.put(user3.getId(), user3);
		hashMap.put(user4.getId(), user4);

		// 遍历数组
		for (User a : user) {
			System.out.println(a);
		}
		System.out.println("------------");

		// 遍历ArrayList
		for (User a : arrayList) {
			System.out.println(a);
		}
		System.out.println("----------------");
		// 遍历HashSet
		for (User a : hashSet) {
			System.out.println(a);
		}
		System.out.println("-----------------");

		// 遍历HashMap
		Set<String> keySet = hashMap.keySet();
		for (String a : keySet) {
			User u = hashMap.get(a);
			System.out.println(u);
		}
		System.out.println("-------------");
		// 另一种遍历HashMap
		Set<Entry<String, User>> entrySet = hashMap.entrySet();
		for (Entry<String, User> a : entrySet) {
			System.out.println(a.getKey() + "," + a.getValue());

		}
		System.out.println("------------");
		// 从list中找出年龄最大的user对象
		User a = arrayList.get(0);
		for (int i = 0; i < arrayList.size(); i++) {
			if (arrayList.get(i).getAge() > a.getAge()) {
				a = arrayList.get(i);
			}
		}
		System.out.println("list中年龄最大的对象：" + a);
		System.out.println("------------------");
		//从set中找出薪水最高的user对象
		Iterator<User> iterator = hashSet.iterator();//使用迭代器工具
		User uset = iterator.next();//取出一个对象作为基准对象，来比较
		for(User aa:hashSet) {
			if(aa.getSalary()>uset.getSalary()) {
				uset=aa;
			}
		}
		System.out.println("set中薪水最高的对象："+uset);
		System.out.println("------------------");
		//从map中找出age最小的user对象
		Set<String> keySet2 = hashMap.keySet();//将map的key放入set
		Iterator<String> iterator2 = keySet2.iterator();//使用迭代器工具
		String onemapkey = iterator2.next();//set再利用迭代器取出一个key
		User onemap =hashMap.get(onemapkey);//通过取出的key，生成一个基准对象来比较
		for(String mapkey:keySet2) {
			if(hashMap.get(mapkey).getAge()<hashMap.get(onemapkey).getAge()){
				onemap = hashMap.get(mapkey);
			}
		}
		System.out.println("map中年龄最小的对象："+onemap);
	}
}

第6点

package day06;

public class Product {
	private String pId;
	private String pName;
	private float price;
	private int num;
	
	
	public Product() {

	}

	public Product(String pId, String pName, float price, int num) {
		this.pId = pId;
		this.pName = pName;
		this.price = price;
		this.num = num;
	}
	
	public String getpId() {
		return pId;
	}
	public void setpId(String pId) {
		this.pId = pId;
	}
	public String getpName() {
		return pName;
	}
	public void setpName(String pName) {
		this.pName = pName;
	}
	public float getPrice() {
		return price;
	}
	public void setPrice(float price) {
		this.price = price;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}

	@Override
	public String toString() {
		return "Product [pId=" + pId + ", pName=" + pName + ", price=" + price + ", num=" + num + "]";
	}
	
	
}




package day06;

import java.util.ArrayList;
import java.util.HashMap;

public class ProductTet {
	public static void main(String[] args) {
		Product p1 = new Product("01","咖啡1",55,2);
		Product p2 = new Product("02","咖啡2",65,1);
		Product p3 = new Product("03","咖啡3",75,4);
		Product p4 = new Product("04","咖啡4",85,1);
		Product p5 = new Product("05","咖啡5",85,1);
		
		User u1 = new User("1", "张三1", "123456", "110", 18, 1800);
		User u2 = new User("2", "张三2", "123456", "110", 28, 2800);
		User u3 = new User("3", "张三2", "123456", "110", 38, 3800);
	    
		//根据人名来查找，加入购物车的商品
		//使用HashMap，以人名做key，将产品存储到list作为value；
		HashMap<String, ArrayList<Product>> carMap = new HashMap<>();
		Product p11 = new Product("01","咖啡1",55,2);
		Product p31 = new Product("03","咖啡3",75,4);
		Product p51 = new Product("05","咖啡5",85,1);
		
		//向list中添加商品
		ArrayList<Product> zs1_List = new ArrayList<>();
		zs1_List.add(p11);
		zs1_List.add(p31);
		zs1_List.add(p51);	
		//向hashmap中存储内容
		carMap.put(u1.getName(), zs1_List);
		
		//第二个例子
		Product p22 = new Product("02","咖啡2",65,1);
		Product p32 = new Product("03","咖啡3",75,2);
		Product p42 = new Product("04","咖啡4",85,1);
		
		ArrayList<Product> zs2_List = new ArrayList<>();
		zs2_List.add(p22);
		zs2_List.add(p32);
		zs2_List.add(p42);
		
		carMap.put(u2.getName(), zs2_List);
		
		//测试工具方法，找任务的产品列表
		ArrayList<Product> pdts= ProductTet.findpddbyName(carMap, "张三1");
		System.out.println(pdts);
	}
	
	//工具类，输入人名，返回商品list，list内有商品对象。
	public static ArrayList<Product> findpddbyName(HashMap<String, ArrayList<Product>> carMap,String userName){
		ArrayList<Product> list= carMap.get(userName);
		
		return list;
	}
		
}