2021.10.23 晴
set:
Set是一个无序集合,既存入集合的顺序和取出的顺序不一致Set是一个无序集合,既存入集合的顺序和取出的顺序不一致
Set集合中元素不重复
package study;
import java.util.Set;
import java.util.TreeSet;
/**
* set特点 : 无序 不可重复,添加顺序和取出顺序不一定一致
*
* TreeSet : 存进去的元素,会按照某个规则进行排序
*
* 数字 : 从小到大
* 字符串 : 每一位的ASCII
* 日期 : 自然日期
* @author 落华见樱
*
*/
public class Part01 {
public static void main(String[] args) {
// 数字 升序排序
Set set = new TreeSet();
set.add(10);
set.add(1);
set.add(2);
// 重复的添加不进去
set.add(2);
// 报错, 因为不是相同类型比较的时候回出现问题
// set.add("xxx");
// [1, 2, 10]
System.out.println(set);
for (Object object : set) {
}
// 字符串 比较ASCII
Set strs = new TreeSet();
strs.add("123");
strs.add("12");
strs.add("1");
strs.add("2");
strs.add("21");
strs.add("3");
// [1, 12, 123, 2, 21, 3]
System.out.println(strs);
}
}
package study;
import java.util.ArrayList;
import java.util.Collections;
import java.util.TreeSet;
/**
* TreeSet为什么可以排序?
* 因为添加的元素都实现了Comparable接口
* 在向TreeSet中添加数据的时候,会自动调用该对象的compareTo()方法
* 所以 存储自定义类型的时候,如果要使用TreeSet 那么 必须实现Comparable接口
* @author 落华见樱
*
*/
public class Part02 {
public static void main(String[] args) {
User u1 = new User(18);
User u2 = new User(19);
User u3 = new User(13);
User u4 = new User(15);
TreeSet set = new TreeSet();
set.add(u1);
set.add(u2);
set.add(u3);
set.add(u4);
System.out.println(set);
ArrayList users = new ArrayList();
users.add(u1);
users.add(u2);
users.add(u3);
users.add(u4);
// 也会自动调用comparable中的comparTo方法
Collections.sort(users);
System.out.println(users);
}
}
class User implements Comparable {
private int age;
@Override
public int compareTo(Object o) {
// this是要添加的元素
// o是集合中的元素
if (o instanceof User) {
User user = (User) o;
// 如果该方法返回 0 说明相等.不添加
// 如果该方法返回 小于0 说明要添加的元素比集合中的元素小,就放前面
// 如果该方法返回 大于0 说明要添加的元素比集合中的元素大,就放后面
return this.age - user.age;
}
return 0;
}
public User(int age) {
super();
this.age = age;
}
@Override
public String toString() {
return "User [age=" + age + "]";
}
}
对象排序,就是比较大小,要实现Comparable或Comparator比较器之一,才有资格做比较排序。
【介绍】
1. Comparable:与对象紧相关的比较器,可以称“第一方比较器”。
2. Comparator:此为与具体类无关的第三方比较器。
package study;
import java.util.Comparator;
import java.util.TreeSet;
/**
* 比较器两种方式 :
* 1 要添加的元素实现Comparable接口并覆写compareTo方法
* 2 集合比较器 : Comparator比较器,元素自身不需要实现该接口
*
* 如果添加的元素不是我们自定义的类
* 1 假如该类有排序,但是不是我们想要的结果,比如Integer,默认升序
* 但是我们想要降序 可以使用 Comparator
* 2 假如该类没有排序,没有实现Comparable,那么我们想要排序还是要使用Comparator
* 因为类不是我们写的,所以我们无法更改人家的源码
*
* 如果添加的元素是我们写的,那么想要排序 使用 Comparable ,这样如果不能满足其他用户的排序规则,
* 别人也可以使用 Comparator 进行更改
*
* 当comparable和comparator同时存在,那么 comparator的优先级大于 comparable
* @author 落华见樱
*
*/
public class Part03 {
public static void main(String[] args) {
TreeSet set = new TreeSet(new Comparator(){
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer) o1;
Integer i2 = (Integer) o2;
// 0 说明重复,不添加
// 大于0 往后放
// 小于0 往前放
return i2 - i1;
}
});
set.add(1);
set.add(3);
set.add(6);
set.add(2);
System.out.println(set);
}
}
package study;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* List想要排序,元素必须实现Comparable接口
*
* 如果没有实现 需要用 Comparator
* @author 落华见樱
*
*/
public class Part04 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(1);
list.add(11);
list.add(2);
list.add(3);
list.add(14);
// 因为Integer 实现了Comparable接口,所以可以进行排序,默认升序
Collections.sort(list);
System.out.println(list);
// 假如 Integer没有实现Comparable 或者我们想要降序排序,那么Integer就无法满足我们的要求
// 需要使用Comparator解决
Collections.sort(list,new Comparator () {
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer) o1;
Integer i2 = (Integer) o2;
// 降序
return i2-i1;
}
});
System.out.println(list);
}
}
泛型:
package study;
import java.util.ArrayList;
import java.util.List;
/**
* 范型 : 类型检查,在编译时检查类型是否匹配
*
* 集合中 什么元素都能保存,太杂,优点就是可以保存任意类型的数据,缺点 就是操作起来必须先强制类型转换才行
* 否则因为多态,无法访问特有属性
*
* 引入范型之后,那么该集合中就只能保存指定类型,优点 : 操作起来方便,缺点 : 只能保存指定的类型
*
* 而结合实际操作,我们绝大部分都是用来保存统一类型的数据的
*
* 范型 只能写引用类型,不能写基本类型
*
* 使用大写字母表示 : A,B,C,D,E,F,......X,Y,Z 都是可以的,只不过是一个占位符而已
* 但是还是要合理选择
* ? 表示不确定的类型
* T(Type) : 表示是一个具体的java类型
* E(Element) : 表示是元素的类型 (集合中保存的是元素)
* K , V
* 如果说规定了泛型,但是没有传入泛型类型,那么 默认是Object
* @author 落华见樱
*
*/
public class Part06 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(1);
list.add(123);
list.add("xxx");
list.add(true);
for (Object object : list) {
if (object instanceof String) {
String s = (String) object;
System.out.println(s.toLowerCase());
}
}
List<Integer> list1 = new ArrayList<Integer>();
list1.add(123);
// 不能保存字符串
// list1.add("22");
for (Integer integer : list1) {
System.out.println(integer);
}
}
}
package study;
/**
* 自定义类型
* @author 落华见樱
*
*/
public class Part07 {
public static void main(String[] args) {
Test1 t = new Test1();
t.m1(1);
t.m1("xxx");
t.m1("xxx");
t.m1("xxx");
t.m1("xxx");
t.m1("xxx");
Test1<String> t1 = new Test1<String>();
Test1<Integer> t2 = new Test1<Integer>();
// t1.m1(1);
t1.m1("xxx");
t2.m1(1);
// t2.m1("xx");
}
}
class Test1<T> {
public void m1(T e) {
String s = (String) e;
}
}
package study;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
/**
* 需求 : 按照字符串中的数值大小进行排序,而不是按照ASCII
* @author 落华见樱
*
*/
public class Part05 {
public static void main(String[] args) {
// 字符串 比较ASCII
Set strs = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
// 1 Object 转换为String
String s1 = (String) o1;
String s2 = (String) o2;
// 2 把String转换为 int
int i1 = Integer.parseInt(s1);
int i2 = Integer.parseInt(s2);
// 3 比较
return i1 - i2;
}
});
strs.add("123");
strs.add("12");
strs.add("1");
strs.add("2");
strs.add("21");
strs.add("3");
System.out.println(strs);
}
}