Java笔记之集合框架Set&Map

Set集合

元素是无序的，不可重复的不存在下标的，遍历需要使用迭代器和foreach继承collection接口，没有get()方法实现类hashSet()
-实现类 linkedHashSet() 插入顺序和迭代顺序一致常用方法

		Scanner s=new Scanner(System.in);
		System.out.println("请输入字符串");
		String str=s.next();
		Set set=new HashSet();
		char[] ch=str.toCharArray();
		for(char c:ch) {
			set.add(c);
		}
		for(Object o:set) {
			System.out.println(o);
		}

需求:在Hashset中存储3个员工，每个员工要保存的信息是员工编号，员工姓名，员工年龄工并演示2种方式进行迭代,输出员工的信息。

		package com.m.demo2;

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

public class Test2 {

	public static void main(String[] args) {
		//命名规范
		Set empSet=new HashSet<>();
		empSet.add(new Emp("001","a",12));
		empSet.add(new Emp("002","b",12));
		empSet.add(new Emp("003","c",12));
		Iterator iterator = empSet.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		System.out.println("==================");
		for(Emp e:empSet) {
			System.out.println(e);
		}
	}

}

需求:在上题中添加一个重复的元素，并进行迭代，输出元素。查看元素个数尝试添加null对象，是否可以添加?

//命名规范 类型名字+集合类型
		Set empSet=new HashSet<>();
		empSet.add(new Emp("001","a",12));
		empSet.add(null);
		empSet.add(new Emp("002","b",12));
		empSet.add(new Emp("003","c",12));
		empSet.add(new Emp("002","b",12));//重复元素
		Iterator iterator = empSet.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		System.out.println("==================");
		for(Emp e:empSet) {
			System.out.println(e);
		}
		System.out.println(empSet.size());

Set集合过滤重复的原理

原理:将存入到集合对象用equals与集合中实际保存的对象一一比较。如果相等，视为同一个对象，set将不会保存。如果不相等，视为不同对象。set就会存储对象。
使用时，如果set集合保存自己定义的对象，假如把属性值完全一样的对象视为同一个对象，不希望set集合保存属性值完全一样的对象，重写对象所属类型的equals()和hashCode()。

map集合

它是以Key-Value方式存储数据的，key不能重复，但是可以为null，value的值可以重复。每个元素的数据结构由两部分键和值组成。通过键可以找值。键key可以组成一个集合，它的值又可以组成一个集合。所以我们把它叫做双列集合。

put(key,value) 如果put的key 一样但值不同，后一个会覆盖前一个hashMap,hashTableremove删除返回旧值遍历map方式
通过keySet()方法找到所有的Key的集合（Set）
遍历Set找到所有值的集合

		Map map=new HashMap<>();
		map.put("张三", 3);
		map.put("李四", 5);
		map.put("王五", 4);
		Set keySet = map.keySet();
		for(String s:keySet) {
			System.out.println(s+" "+map.get(s));
		}

遍历方式直接找到key和value

Set> entrySet() 
返回此地图中包含的映射的Set视图。

返回的是键和值的集合（entry.key,entry.value）

Map map=new HashMap<>();
		map.put("张三", 3);
		map.put("李四", 5);
		map.put("王五", 4);
		Set> entrySet = map.entrySet(); 
		Iterator> iterator = entrySet.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}

判断存在

boolean containsKey(Object key) 
如果此映射包含指定键的映射，则返回 true 。

boolean containsValue(Object value) 
如果此地图将一个或多个键映射到指定的值，则返回 true 。

boolean isEmpty() 
如果此地图不包含键值映射，则返回 true 。 
是否不存在元素

Collection values() 
返回此地图中包含的值的Collection视图。
可以获取所有值，但是不能获取key

需求:Scanner接收用户输入一个字符串。“aaabbbccdd” ,过滤重复字符并统计重复次数。

String s="aaabbbbcccc";
		Map map=new HashMap<>();
		
		char[] ch=s.toCharArray();
		for(char c:ch) {
			int num=1;
			if(map.containsKey(c)) {
				num= map.get(c);
				num+=1;
				
			}
				map.put(c,num);
			
		}
		
		
		
		System.out.println(map);

内部类: 在一个类的内部，又有另外一个类。不想让其他类来实例化，只能在MainExample类中实例化
//可以使用private来修饰内部类，实现隐藏该类细节，起到保护作用
//一个类只能继承一个父类，但是如果内部类有多个内部类，就可以通过内部类继承的方式，让类间接继承多个类。

public class A{
classB{
}
}

**内部接口:**在一个接口中，又有另外一个类

public interface A{
   interface B{

}

}

嵌套集合

在集合中放其他集合，类似二维数组

package com.m.demo3;

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

public class Test {

	public static void main(String[] args) {
		Map> map=new HashMap<>();
		System.out.println("请输入N的值");
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();
		for(int i=0;i mapStu=new HashMap<>();
			for(int j=0;j keySet = map.keySet();
		for(String k:keySet) {
			System.out.println("班级名称："+k);
			System.out.println("学号t姓名t年龄t性别");
			Set keySet2 = map.get(k).keySet();
			for(String k2:keySet2) {
				System.out.println(k2+"t"
			           +map.get(k).get(k2).getName()+"t"+
						map.get(k).get(k2).getAge()+"t"+
					    map.get(k).get(k2).getGender());
			}
		}
		

	}

}

Collections工具类的基本应用

该类给集合提供了一些很好用的方法排序sort() 能比较的都实现了Comparable接口，如果想对对象排序，需实现Comparable接口。

static >
void sort(List list) 
根据其元素的natural ordering对指定的列表进行排序。

List list=new ArrayList<>();
		list.add(123);
		list.add(124);
		list.add(111);
		Collections.sort(list);
		System.out.println(list);

学生类按年龄排序

package com.m.demo;

public class Student implements Comparable{
	
	private String name;
	private Integer age;
	private Character gender;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Character getGender() {
		return gender;
	}
	public void setGender(Character gender) {
		this.gender = gender;
	}
	public Student(String name, Integer age, Character gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	@Override
	public int compareTo(Student o) {
		// 将此对象与指定的对象进行比较以进行排序。 
//		返回一个负整数，零或正整数，因为该对象小于，等于或大于指定对象。 
		return this.getAge()-o.getAge();
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
	
	
}

package com.m.demo;

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

public class Test2 {

	public static void main(String[] args) {
		List list=new ArrayList<>();
		list.add(new Student("a",13,'男'));
		list.add(new Student("b",15,'男'));
		list.add(new Student("c",12,'男'));
        Collections.sort(list);
        for(Student s:list) {
        	System.out.println(s);
        }
	}

}

如果年龄相等则按照名字比较，因为String已经重写了compareTo方法，可以直接调用。

@Override
	public int compareTo(Student o) {
		// 将此对象与指定的对象进行比较以进行排序。 
//		返回一个负整数，零或正整数，因为该对象小于，等于或大于指定对象。 
		return this.getAge()-o.getAge()==0?this.getName().compareTo(o.getName()):this.getAge()-o.getAge();
	}

二分查找binarySearch(list)

static  int binarySearch(List> list, T key) 
使用二叉搜索算法搜索指定对象的指定列表。

System.out.println(Collections.binarySearch(list, 123));

反转

static void reverse(List list) 
反转指定列表中元素的顺序。

 Collections.reverse(list);

填充

static  void fill(List list, T obj) 
用指定的元素代替指定列表的所有元素。

随机置换元素位置（类似洗牌）

static void shuffle(List list) 
使用默认的随机源随机排列指定的列表。

Java笔记之集合框架Set&Map

Java相关栏目本月热门文章