一.LinkedHashSet
1.LinkedHashSet 有序 去重
public class Day15 {
public static void main(String[] args) {
LinkedHashSet<String> set = new LinkedHashSet();
set.add("a");
set.add("b");
set.add("c");
set.add("d");
Iterator<String> iterator = set.iterator();
//迭代器循环
while(iterator.hasNext()){
String str = iterator.next();
System.out.println(str);a b c d
}
利用set集合去除ArrayList集合中的重复元素(操作原ArrayList),ArrayList 保存a a, b b, c c
//利用set集合去除ArrayList集合中的重复元素(操作原ArrayList),ArrayList 保存a a, b b, c c
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("a");
arrayList.add("a");
arrayList.add("b");
arrayList.add("b");
arrayList.add("c");
arrayList.add("c");
//创建HashSet集合
HashSet<String> hashSet = new HashSet<>();
//将ArrayList中的元素全部放入HashSet集合中,去重
hashSet.addAll(arrayList);
//清空arrayList集合
arrayList.clear();
//将去重的元素放入arrayList集合中
arrayList.addAll(hashSet);
System.out.println(arrayList);//[a, b, c]
}
}
二.TreeSet
1.TreeSet 无序 无下标 不重复
功能: 排序(默认升序) 去重
2.排序的步骤:
1).实现compareable接口
2).实现接口中的方法
3).重写排序规则
//创建TreeSet保存四个数字
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(4);
treeSet.add(6);
treeSet.add(2);
treeSet.add(9);
//去重 排序以升序
System.out.println(treeSet);//输出:[2, 4, 6, 9]
public class Day15 {
public static void main(String[] args) {
//声明集合保存四个字符串,按字符串长度排序
//comparator 比较器 接口 编写比较接口
//将比较的规则直接传入到treeSet的构造方法中
//比较系统的类要重写一个类实现Comparator接口,重写比较规则,在创建集合时调用
TreeSet<String> treeSet = new TreeSet<>(new CompareString());
treeSet.add("hahd");
treeSet.add("ha");
treeSet.add("kafjd");
treeSet.add("wtad");
System.out.println(treeSet);//[ha, hahd, wtad, kafjd]
}
}
//比较字符串长度的类实现接口
class CompareString implements Comparator<String>{
//重写比较规则
@Override
public int compare(String o1, String o2) {
int num = o1.length() - o2.length();
return num = num == 0 ? 1 : num;
}
}
在一个集合ArrayList中存储了无序并且重复的字符串
要求: 排序,而且还不能去除重复(用比较器),主要按字符串长度比较 次要按字符串比
public class Day15 {
public static void main(String[] args) {
TreeSet<String> treeSet = new TreeSet<>(new StringSort());
treeSet.add("af");
treeSet.add("geaf");
treeSet.add("af");
treeSet.add("agf");
treeSet.add("ggae");
System.out.println(treeSet);
}
}
//主要按字符串长度比较 次要按字符串比规则
class StringSort implements Comparator<String>{
//重写比较规则
@Override
public int compare(String o1, String o2) {
//比较长度相等
int num = o1.length() - o2.length();
//长度相等时比较字符
int rel = num == 0 ? o1.compareTo(o2) : num;
//字符相等时赋值1否则为rel
return rel == 0 ? 1 : rel;
}
}
键盘接收一个字符串, 对其中所有字符进行排序 要求保留重复的
public class Day15 {
public static void main(String[] args) {
System.out.println("请输入一个字符串");
Scanner scanner = new Scanner(System.in);
String str = scanner.nextLine();
//字符串转数组
char[] charArray = str.toCharArray();
TreeSet<Character> treeSet = new TreeSet<>();
for (int i = 0; i < charArray.length; i++) {
//遍历数组将元素放入集合中
treeSet.add(charArray[i]);
}
System.out.println(treeSet);
}
}
//字符比较
class CharSort implements Comparator<Character>{
@Override
public int compare(Character o1, Character o2) {
int num = o1.compareTo(o2);
return num = num == 0 ? 1 :num;
}
}
程序启动后, 可以从键盘输入接收多个整数,直到输入quit时结束输入,把所有输入的整数降序排列打印.
public class Day15 {
public static void main(String[] args) {
System.out.println("请输入整数,以quit结束输入");
Scanner scanner = new Scanner(System.in);
TreeSet<Integer> treeSet = new TreeSet<>(new CompareNum());
while (true) {
String string = scanner.nextLine();
//判断是否结束循环
if (string.equals("quit")) {
break;
}
//字符串转整数
int num = Integer.parseInt(string);
//将整数存入集合
treeSet.add(num);
}
System.out.println(treeSet);
}
}
//比较数字
class CompareNum implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
int num = o1 - o2;
return num = num == 0 ? 1 : num;
}
}
键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)
录入的学生信息格式(姓名,语文成绩,数学成绩,英语成绩)
按照总分从高到低输出到控制台。输出学生所有信息
public class Day15 {
public static void main(String[] args) {
System.out.println("请输入姓名,语文成绩,数学成绩,英语成绩");
Scanner scanner = new Scanner(System.in);
TreeSet<Student> treeSet = new TreeSet<>(new Student());
for (int i = 0; i < 5; i++) {
String string = scanner.nextLine();
//以,分割字符串
String[] array = string.split(",");
//将成绩转为整数
int chinese = Integer.parseInt(array[1]);
int math = Integer.parseInt(array[2]);
int english = Integer.parseInt(array[3]);
//创建学生对象
Student student = new Student(array[0], chinese, math, english);
//将学生放入集合
treeSet.add(student);
}
System.out.println(treeSet);
}
}
//创建人类
class Person implements Comparable<Person>{
private String name;
private int age;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
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() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Person o) {
// TODO Auto-generated method stub
//重写排序规则
//以年龄排序(升序)
int num = this.age - o.getAge();
return num;
}
}
//学生类
//学生信息格式(姓名,语文成绩,数学成绩,英语成绩)
public class Student implements Comparator<Student>{
private String name;
private int chinese;
private int math;
private int english;
private int sum;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int chinese, int math, int english) {
super();
this.name = name;
this.chinese = chinese;
this.math = math;
this.english = english;
//计算总分
this.sum = this.chinese + this.math + this.english;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getChinese() {
return chinese;
}
public void setChinese(int chinese) {
this.chinese = chinese;
}
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getEnglish() {
return english;
}
public void setEnglish(int english) {
this.english = english;
}
public int getSum() {
return sum;
}
public void setSum(int sum) {
this.sum = sum;
}
@Override
public String toString() {
return "Student [name=" + name + ", chinese=" + chinese + ", math=" + math + ", english=" + english + ", sum="
+ sum + "]";
}
//重写排序规则,按照总分排,并且不能去重
@Override
public int compare(Student o1, Student o2) {
// TODO Auto-generated method stub
int num = o1.sum - o2.sum;
return num = num == 0 ? 1 : num;
}
}
三.Map
1.map是双列集合的父接口
特点:
1).以键值对形式来存储数据 key—value
2)健值唯一(健值不能重复)
2.hashSet和hashMap的关系:
hashSet 依赖 hashMap,实际上向hashSet中添加元素是向hashMap的key列添加元素
public class Day15 {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
//添加键值对元素
//put方法的返回值是该键被覆盖的value的值
Integer put = map.put("张三", 18);
Integer put2 = map.put("李四", 21);
Integer put3 = map.put("王五", 16);
Integer put4 = map.put("王五", 30);
System.out.println(map);
System.out.println(put);
System.out.println(put2);
System.out.println(put3);
System.out.println(put4);
}
}
Map的方法:
HashMap<String, Integer> hashMap = new HashMap<>();
Integer put = hashMap.put("张三", 18);
Integer put2 = hashMap.put("李四", 21);
Integer put3 = hashMap.put("王五", 16);
Integer put4 = hashMap.put("麻子", 25);
//判断是否包含key
boolean b1 = hashMap.containsKey("李四");
System.out.println(b1);
//判断是否包含value
boolean b2 = hashMap.containsValue(21);
System.out.println(b2);
//取出所有key的set集合
Set<String> keySet = hashMap.keySet();
System.out.println(keySet);
//取出所有value的集合
Collection<Integer> values = hashMap.values();
System.out.println(values);
//通过key将整个键值对删除
Integer remove = hashMap.remove("李四");
System.out.println(remove);
//清空hasMap
hashMap.clear();
System.out.println(hashMap);
通过迭代器遍历map
HashMap<Person, String> hashMap = new HashMap<>();
hashMap.put(new Person("李四", 18), "山西");
hashMap.put(new Person("张三", 20), "陕西");
hashMap.put(new Person("王五", 22), "新疆");
hashMap.put(new Person("王五", 22), "新疆");
Set<Person> keySet = hashMap.keySet();
Iterator<Person> iterator = keySet.iterator();
while (iterator.hasNext()) {
Person key = iterator.next();
String value = hashMap.get(key);
System.out.println(key +" = "+ value);
}
//利用Entry对象遍历Map
//Entry对象中分装了一对键值对对象 key---value
HashMap<String, Integer> hashMap = new HashMap<>();
Integer put = hashMap.put("张三", 18);
Integer put2 = hashMap.put("李四", 21);
Integer put3 = hashMap.put("王五", 16);
//获取所有entry对象的set集合
Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet();
//取出迭代器
Iterator<Entry<String, Integer>> iterator = entrySet.iterator();
//遍历所有entry对象
while (iterator.hasNext()) {
//取出集合中的每一个entry对象
Entry<String, Integer> entry = iterator.next();
Integer value = entry.getValue();
String key = entry.getKey();
System.out.println(key +" = "+ value);
}