Java入门学习第十三天————泛型、Collections工具类、Set集合、Map集合
程序员文章站
2022-07-14 23:29:27
...
Java常用工具——集合
什么是泛型？
即泛指任意类型，又叫参数化类型（ParameterizedType）,对具体类型的使用起到辅助作用，类似于方法的参数。
集合类泛型的解释
表示该集合中存放指定类型的元素
案例演示：给List集合加上泛型String
泛型的好处：类型安全，避免了类型转换
package study5.demo;
import java.util.ArrayList;
import java.util.List;
//总结：泛型一般只和集合类相结合使用；泛型是JDK5的新特性，但是从JDK7开始，后边的泛型可以不用谢具体的数据类型了（菱形泛型）
public class Test13 {
public static void main(String[] args) {
// 需求：演示泛型
// 不使用泛型的集合
// 1.创建集合对象
List list = new ArrayList();
// 2.创建元素对象
// 3.将元素对象添加到集合对象中
list.add("a");
list.add("b");
list.add("c");
// list.add(10); //报错：类型转换异常：ClassCastException,10为Integer类型，不能转成String类型
// 4.遍历集合
for (Object obj : list) {
String s = (String)obj;
System.out.println(s);
}
System.out.println("————————————");
// 1.创建集合对象
// List<String> list1 = new ArrayList<String>(); JDK5的形式
List<String> list1 = new ArrayList<>(); //JDK7以后的形式
// 2.创建元素对象
// 3.将元素对象添加到集合元素中
list1.add("a");
list1.add("b");
list1.add("c");
// 4.遍历
for (String s : list1) {
System.out.println(s);
}
}
}
Collections工具类
Collections简介：针对集合进行操作的工具类，都是静态的，所以可以通过 类名. 的方式来调用
成员方法
sort(List):根据元素的自然排序，将指定列表按升序排序
max(Collections):返回集合的最大元素
reverse(List):反转List集合中的元素
shuffle(List):使用默认的随机源置换指定的列表
案例演示：
package study5.demo;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Colle {
public static void main(String[] args) {
// 创建集合
List<Integer> list = new ArrayList<>();
// 往集合里添加元素
list.add(1);
list.add(2);
list.add(3);
list.add(10);
list.add(4);
list.add(5);
list.add(6);
System.out.println("没有操作以前，集合中的数据是："+list);
System.out.println("——————————");
Integer max = Collections.max(list);
System.out.println("集合中的最大元素为："+max);
System.out.println("——————————");
Collections.sort(list);
System.out.println("升序排列后的结果为："+list);
System.out.println("——————————");
Collections.reverse(list);
System.out.println("反转以后集合中的数据为"+list);
// 需求：对集合中的数据进行降序排列
// 先对集合中的数据进行升序排列，然后再进行反转
List<Integer> l = new ArrayList<>();
l.add(0);
l.add(6);
l.add(8);
l.add(9);
l.add(11);
l.add(4);
l.add(15);
// 集合中的最大数
// Collections.max(l)后alt+回车，就可生成
Integer max1 = Collections.max(l);
System.out.println("最大的数是："+max1);
Collections.sort(l);
Collections.reverse(l);
System.out.println("降序："+l);
Collections.shuffle(l);
System.out.println("随机置换："+l);
}
}
Set集合
特点：不可重复(唯一性)，无序（元素的存和取是不一致的）
应用：Set set = new HashSet<>();
案例：Set集合的简单应用
需求：向Set集合中添加五个元素，并遍历一遍
package study5.demo;
import java.util.Objects;
public class Person {
private String name;
private int age;
@Override
public String toString() {
return "个人资料：" +
"姓名：'" + name + '\'' +
", 年龄：" + age +
'。';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, 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;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
}
package study5.demo;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
//结论：Set集合保证元素的唯一性依赖equals()和hashCode()两个方法
public class Pertest {
public static void main(String[] args) {
// 1.创建集合对象
Set<Person> set = new HashSet<>();
// 2.创建元素对象
Person p = new Person("p",20);
Person e = new Person("e",20);
Person r = new Person("r",20);
Person s = new Person("s",20);
Person r1 = new Person("r",20);
Person s1 = new Person("s",20);
set.add(p);
set.add(e);
set.add(r);
set.add(s);
set.add(r1);
set.add(s1);
// 4.遍历集合
System.out.println(set); //若是没有重写equals()和hashCode()两个方法，则全部元素对象都会输出，重写之后，重复的对象就不会重复出现
// 为什么Set集合没有去重呢？因为Set集合保证元素的唯一性依赖：equals()和hashCode()两个方法
//因为没有在Person类中重写这两个方法，所以会自动使用Object类中的这两个方法
// 而Object类中的equals()方法默认比较的是地址值是否相同
// 解决方案：在Person类中重写这两个方法
System.out.println("————————————");
// 通过迭代器遍历集合
// 1.通过集合对象获取其对应的迭代器对象
Iterator<Person> it = set.iterator();
// 2.判断迭代器是否有元素
while (it.hasNext()) {
// 3.如果有就获取元素
Person o = it.next();
System.out.println(o);
}
System.out.println("——————————");
// 通过增强for循环遍历集合
System.out.println("通过增强for循环遍历集合");
for (Person person : set) {
System.out.println(person);
}
}
}
结论：Set集合保证元素的唯一性依赖equals()和hashCode()两个方法，可使用快捷键生成，alt+Insert，选中对应的方法之后就一直next至结束
Map集合
特点：双列集合，元素由键值对（Entry）构成：key——value
key不可以重复，value可以重复
双列集合是不能直接遍历的，需要将它先转换成单列集合，再进行遍历
应用：Map<T1,T2> map = new HashMap<>();
案例：Map集合的简单使用
需求：向Map集合中添加三个元素，并遍历打印
向Map集合添加元素的方法为：put();
获取所有的key：keySet();
通过key获取value：get();
package study5.demo;
import java.util.Objects;
public class Student2 {
private String name;
private int age;
public Student2(String name, int age) {
this.name = name;
this.age = age;
}
public Student2() {
}
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 "Student2{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student2 student2 = (Student2) o;
return age == student2.age &&
Objects.equals(name, student2.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
package study5.demo;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
双列集合是不能直接遍历的，需要将它先转换成单列集合，再进行遍历
成员方法：
V put(K key,V value) :添加元素（键值对的形式），
元素第一次添加，返回null，
重复添加，会用新值覆盖旧值，并返回旧值
V get(Object key):根据键获取其对应的值
Set(K) keySet():获取所有键的集合
遍历步骤：
1.获取所有键的集合 keySet()
2.遍历所有的键，获取到每一个键 迭代器，增强for循环
3.根据键，获取指定的值 get()
*/
public class MapDemo {
public static void main(String[] args) {
// 向集合添加三个元素
// 1.创建集合对象
// 键=学生的编号 值=具体的学生对象
Map<Integer,Student2 > map = new HashMap<>();
// 2.创建元素对象
Student2 s = new Student2("a",20);
Student2 t = new Student2("b",22);
Student2 u = new Student2("c",24);
// 3.将元素对象添加到集合中
// Student2 stu1 = map.put(1,s); //元素第一次添加，返回null，
// System.out.println("stu1:"+stu1);
// Student2 stu2 = map.put(1,t);
// System.out.println("stu2:"+stu2);
map.put(1,s);
map.put(2,t);
map.put(3,u);
// 根据键，获取值
Student2 stu2 = map.get(2);
System.out.println("key:"+2+",value:"+stu2);
// 4.打印集合
System.out.println("map的值为："+map);
System.out.println("——————————");
// 遍历集合
// 遍历步骤：
// 1.获取所有键的集合 keySet()
// Set<Integer> keys = map.keySet(); //核心代码，将双列集合转成单列集合
2.遍历所有的键，获取到每一个键 迭代器，增强for循环
获取迭代器对象
// Iterator<Integer> it = keys.iterator();
// while (it.hasNext()) {
// Integer key = it.next();
// // 3.根据键，获取指定的值 get()
// Student2 value = map.get(key);
// System.out.println("key:"+key+",value:"+value);
// }
// 通过增强for实效
// 获取到所有的键
Set<Integer> keys = map.keySet();
for (Integer key : keys) {
// key就是双列集合中的每一个键
Student2 value = map.get(key);
System.out.println("key:"+key+",value:"+value);
}
}
}
上一篇： javaEE学习笔记——第十六天泛型
下一篇： LAMP-(FCGI)-实现虚拟主机