Day-18 散列表、泛型

1 . set

HashSet使用

public static void main(String[] args) {
		HashSet set = new HashSet();
		set.add(1);
		set.add("asd");
		set.remove("asd");
		System.out.println(set.size());
		set.isEmpty();
		for (Object object : set) {
 
		}
	}

散列表
 概述
 HashSet
以上两个截图可看出来,当我们使用HashSet的时候,其实就等于是再使用HashMap

添加数据的时候,虽然调用的是HashSet的add方法,但是本质还是调用map的put方法

Ps : 在map中,put是添加操作

而 map中 需要保存的是k和v映射关系,所以在set中有一个变量保存了value的值

所以我们再进行set添加的时候,只操作了map中的key,value值我们不再关心

 Map
 HashMap
 

 // 创建map
 
                  HashMap map = new HashMap();
 
                  // 添加 K-V
 
                  map.put("A", "one");
 
                  map.put("B", "two");
 
                  map.put("C", "three");
 
                  map.put(65,100);
 
                  map.put('A', "2222");
 
                  // key重复,不添加,value替换
 
                  map.put("A", "2222");
 
                  // 支持K和V都null,但是没有意义
 
                  map.put(null,null);
 
                  // 个数
 
                  System.out.println(map.size());
 
                  // get : 根据K 获取 V的值
 
                  System.out.println(map.get("A"));
 
                  // 判断是否包含某个key
 
                  System.out.println(map.containsKey(65));
 
                  // 判断是否包含某个value
 
                  System.out.println(map.containsValue("one"));
 
                  // 根据key删除 该映射关系,返回对应的value值
 
                  map.remove(65);
 
                  // 获取所有的value,并放到集合中返回
 
                  Collection values = map.values();
 
                  for (Object object : values) {
 
                          System.out.println(object);
 
                  }
 
                  System.out.println("======");
 
                  // keySet : 获取所有的key,封装到set对象中并返回
 
                  Set keys = map.keySet();
 
                  for (Object object : keys) {
 
                          System.out.println(object +":"+map.get(object));
 
                  }
 
                  // 把map转换为set
 
                  // Entry类中,保存了K和V两个变量,把map中的k和v转换为entry类的对象进行存储
 
                  // 所以我们只需要保存entry对象,就等于保存了k和v
 
                  Set set  = map.entrySet();
 
                  for (Object object : set) {
 
                          // C=three
 
                          System.out.println(object);
 
                          // 转换为entry类型
 
                          Entry entry = (Entry) object;
 
                          // 获取k和v
 
                          System.out.println(entry.getKey()+" : "+entry.getValue());
 
                  }

1. 1. reeMap

1.  泛型
   1.  概述

1. 1.  使用方式

   2. public static void main(String[] args) {
      		// 添加自定义类型,并且 Product中 实现了Comparable接口
      		TreeMap map = new TreeMap();
      		map.put(new Product("苹果", 5.3), 10);
      		map.put(new Product("香蕉", 5.6), 10);
      		System.out.println(map.size());
       
      		// 添加已有类型,且该类型实现了Comparable接口,Integer默认升序
      		// 如果 该类型没有实现Comparable接口,或者 我们想要降序,则需要使用Comparator
      		// map = new TreeMap();
      		map = new TreeMap(new Comparator() {
      			@Override
      			public int compare(Object o1, Object o2) {
      				Integer i1 = (Integer) o1;
      				Integer i2 = (Integer) o2;
      				return i2 - i1;
      			}
      		});
      		map.put(11, "a");
      		map.put(2, "a");
      		map.put(23, "a");
      		map.put(3, "a");
      		System.out.println(map.size());
      		System.out.println(map);
      	}
      }
       
      class Product implements Comparable {
      	private String name;
      	private double price;
       
      	public Product(String name, double price) {
      		super();
      		this.name = name;
      		this.price = price;
      	}
       
      	@Override
      	public int compareTo(Object o) {
      		if (o instanceof Product) {
      			Product p = (Product) o;
      			if (this.price > p.price) {
      				return 1;
      			} else if (this.price < p.price) {
      				return -1;
      			}
      		}
      		return 0;
      	}
       
      }

   3. 1. 注意
   5. 1.  自定义泛型

   6. public static void main(String[] args) {
      		// 没有使用泛型
      		List list = new ArrayList();
      		// 什么也能放
      		list.add(new A());
      		list.add(1);
      		// 取的时候,拿到的是Object
      		for (Object object : list) {
      			// 使用需要进行判断和向下转型才行
      			if (object instanceof A) {
      				A a = (A) object;
      				a.m1();
      			}
      		}
      		
      		// 使用泛型 规定 该集合中 只能保存A类型
      		List<A> list2 = new ArrayList<A>();
      		list2.add(new A());
      		// 添加其他的 报错,而且是编译报错
      		// list2.add(2);
      		
      		// 使用的时候,拿到的就直接是A类型,不会出现类型转换异常
      		// 因为只要能运行,里面一定是A
      		for (A a : list2) {
      			a.m1();
      		}
      		
      		// 泛型 不能写基本类型,只能写引用类型
      		// 如果想要保存基本类型,则需要编写对应的包装类类型
      		// List<int> list3 = new ArrayList<int>();
      		List<Integer> list4 = new ArrayList<Integer>();
      		
      		// 如果 需要保存多种数据,则不需要使用泛型
      		// 但是如果需要保存同一种类型的数据,则一定要使用泛型,这样方便操作
      		
      		// set和map使用泛型
      		Set<String> set = new HashSet<String>();
      		Map<String, Integer> map = new HashMap<String, Integer>();
      	}
      }
      class A {
      	public void m1(){
      		System.out.println("m1执行了");
      	}
      }