散列表、泛型

1.  Set
   1.  HashSet使用

   2. 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) {
      
      		}
      	}

1.  散列表
   1.  概述

1. 1.  HashSet

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

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

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

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

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

1.  Map

1. 1.  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.      TreeMap

1.  泛型
   1.  概述

1. 1.  使用方式

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;
	}

}

1. 1.  注意

1. 1.  自定义泛型

1.  题

   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执行了");
   	}
   }