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<Emp> 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<Emp> iterator = empSet.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("==================");
for(Emp e:empSet) {
System.out.println(e);
}
}
}
需求:在上题中添加一个重复的元素,并进行迭代,输出元素。查看元素个数尝试添加null对象,是否可以添加?
//命名规范 类型名字+集合类型
Set<Emp> 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<Emp> 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,hashTable
- remove删除 返回旧值
- 遍历map方式
通过keySet()方法找到所有的Key的集合(Set)
遍历Set找到所有值的集合
Map<String,Integer> map=new HashMap<>();
map.put("张三", 3);
map.put("李四", 5);
map.put("王五", 4);
Set<String> keySet = map.keySet();
for(String s:keySet) {
System.out.println(s+" "+map.get(s));
}
遍历方式 直接找到key和value
Set<Map.Entry<K,V>> entrySet()
返回此地图中包含的映射的Set视图。
返回的是键和值的集合(entry.key,entry.value)
Map<String,Integer> map=new HashMap<>();
map.put("张三", 3);
map.put("李四", 5);
map.put("王五", 4);
Set<Entry<String, Integer>> entrySet = map.entrySet();
Iterator<Entry<String, Integer>> 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<V> values()
返回此地图中包含的值的Collection视图。
可以获取所有值,但是不能获取key
需求:Scanner接收用户输入一个字符串。“aaabbbccdd” ,过滤重复字符并统计重复次数。
String s="aaabbbbcccc";
Map<Character,Integer> 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<String,Map<String,Student>> map=new HashMap<>();
System.out.println("请输入N的值");
Scanner s=new Scanner(System.in);
int n=s.nextInt();
for(int i=0;i<n;i++) {
System.out.println("请输入班级名称");
String className = s.next();
Map<String,Student> mapStu=new HashMap<>();
for(int j=0;j<n;j++) {
System.out.println("请输入学生学号");
String stuId = s.next();
System.out.println("请输入学生名字");
String stuName = s.next();
System.out.println("请输入学生年龄");
int age = s.nextInt();
System.out.println("请输入学生性别");
char gender=s.next().charAt(0);
mapStu.put(stuId, new Student(stuName,age,gender));
}
map.put(className, mapStu);
}
//使用键迭代
Set<String> keySet = map.keySet();
for(String k:keySet) {
System.out.println("班级名称:"+k);
System.out.println("学号\t姓名\t年龄\t性别");
Set<String> 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 <T extends Comparable<? super T>>
void sort(List<T> list)
根据其元素的natural ordering对指定的列表进行排序。
List<Integer> 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<Student>{
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<Student> 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 <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二叉搜索算法搜索指定对象的指定列表。
System.out.println(Collections.binarySearch(list, 123));
- 反转
static void reverse(List<?> list)
反转指定列表中元素的顺序。
Collections.reverse(list);
- 填充
static <T> void fill(List<? super T> list, T obj)
用指定的元素代替指定列表的所有元素。
- 随机置换元素位置(类似洗牌)
static void shuffle(List<?> list)
使用默认的随机源随机排列指定的列表。