华杉研发九学习日记19
一，sort自定义排序
List中有对其中元素进行自定义排序的方式:
void sort (Comparator<? super E> c)
// 按比较器提供的方法进行排序
默认对简单数据类型进行排序:
自定义排序规则:
升序–第一个数据减去第二个数据为升序
降序–第二个数据减去第一个数据为降序
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
System.out.println(list);
// 排序
//升序--第一个数据减去第二个数据为升序
//
//降序--第二个数据减去第一个数据为降序
// list.sort((o1,o2)->o2-o1); lambda表达式
list.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
System.out.println(list);
可以对复杂类型进行排序：
List<Worker> list = new ArrayList();
list.add(new Worker("zhangsan",21,3000));
list.add(new Worker("lisi",25,3600));
list.add(new Worker("wangwu",22,3200));
list.add(1,new Worker("zhaoliu",22,3300));
// 自定义排序 -- 复杂类型 先按照年龄降序排序，再按照工资升序排序
list.sort(new Comparator<Worker>() {
@Override
public int compare(Worker o1, Worker o2) {
int age=o2.getAge()-o1.getAge();
if(age!=0) {
return age;
} else{
return (int)(o1.getSalary()-o2.getSalary());
}
}
});
System.out.println(list);
二，Set
**Set也是一个集合接口，它是对数学中集合的抽象，集合中不包含重复元素。**既然是不含重复元素合。那它就具有排除重复元素的能力。
Set接口就是set集合，是一个**无序的，**不可包含重复元素的单列集合。
Set接口中并没有声明多少独特的方法。而是声明了和父接口相同的方法。
三，HashSet
HashSet保存数据是以哈希表的形式来保存数据。
HashSet是Set集合的实现子类，该子类继承了Set,Collection接口中的方法。
HashSet的构造器:
Hashseto//创建一个空集合，集合的初始容量是16.加载因子是0.75
Hashset(collection<? extends E> c)//创建一个包含指定元素的集合，会去除重。加载因子是0.75
Hashset(int capacity)//创建一个指定初始容r的空集合。加载因子是0.75
Hashset(int capacity，int loadFactor)//创建一个空集合，指定初始容量和加载因子。
代码测试：
Set set = new HashSet();
set.add("小猫咪");
set.add(2);
set.add(3);
boolean bo =set.add(3);
System.out.println(bo);
System.out.println(set);
System.out.println(set.size());
System.out.println(set.isEmpty());
set.remove(2);
System.out.println(set);
set.clear();
System.out.println(set);
// 泛型
Set<Integer> set1 = new HashSet();
set1.add(11);
set1.add(22);
Set<Integer> set2 = new HashSet();
set2.add(33);
set2.add(44);
set1.addAll(set2);
System.out.println(set1);
System.out.println(set1.contains(set2));
set1.removeAll(set2);
System.out.println(set1);
// 遍历方式 只有两种，不能用普通for循环，因为是无序的
// 方式一：加强型for循环
for(Integer i : set1)
System.out.println(i);
// 方式二：迭代器
System.out.println("===========");
Iterator it = set1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
Set集合中如果元素是复杂数据类型，则重复失效，则需要重写hashCode方法外，还要重写equals(Object o)方法
Set去重机制:
1.先判断对象hashCode是否一样，如果hashCode不同，认为是不同的元素。如果hashcode相同,进入下面的判断。
⒉.判断equals方法返回值是true还是false，如果是false认为是不同的元素，如果相同认为是元素重复。不再添加进集合。
四，LinkedHashSet实现类
LinkedHashSet是HashSet的子类，它具有和HashSet同样的功能，元素也是不能重复，唯一不同的是，LinkedHashSet会维持元素加入的顺序。LinkedHashSet和LinkedList一样，底层数据结构是双向链表。
LinkedHashSet是一个有序的，不可包含重复元素的set集合。
LinkedHashSet构造器：
LinkedHashset()//创建一个空集合，集合的初始容量是16，加载因子是0.75
LinkedHashSet(co11ection<? extends E> c)//创建一个包含指定元素的集合，会去除重。加载因子是0.75
LinkedHashset(int capacity)//创建一个指定初始容量的空集合。加载因子是0.75
LinkedHashset(int capacity，int loadFactor)//创建一个空集合，指定初始容量和加载因子。
代码测试：
// 有序的不可重复的集合
Set<String> set = new LinkedHashSet<String>();
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("d");
System.out.println(set);// [a, b, c, d]
//遍历
for(String s : set)
System.out.println(s);
System.out.println("==============");
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
五，TreeSet实现类
TreeSet是内容有序的集合，即它会对放入其中的数据按内容进行排序，它底层数据结构是二叉树。
TreeSet<String> ts = new TreeSet();
ts.add("A");
ts.add("B");
ts.add("你干嘛");
ts.add("C");
ts.add("D");
System.out.println(ts);
//
ts.remove("A");
System.out.println(ts.size());
//遍历方式
for (String s : ts) {
System.out.println(s);
}
System.out.println("===================");
Iterator<String> it = ts.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
System.out.println("===================");
// 多了个迭代倒序 descendingIterator()
Iterator<String> it2 = ts.descendingIterator();
while(it2.hasNext()){
System.out.println(it2.next());
}
思考:TreeSet能对数据进行排序?它怎么知道我想怎么排序?
TreeSet可以对数据进行排序，但排序规则由你来定
两种排序：
自然排序Comparable：
被放入TreeSet的数据，必须实现Comparable接口。Comparable接口中只有一个方法 intcompareTo(T t)，即被放入TreeSet中的对象要实现compareTo方法，TreeSet每放入一个元素，就会拿这个元素和已有元素比较（用compareTo方法比较)，最终确定新添加的数据的位置，使TreeSet集合所有元素有序。
要求:
-
1.元素对象必须实现Comparable
-
2.重写compareTo自定义排序规则
@Override
public int compareTo(Teacher o) {
// 年龄升序
// 升序，第一个数据减第二个数据
// 降序，第二个数据减第一个数据
int a=this.getAge()-o.getAge();
if(a==0){
return (int)(this.getSalary()-o.getSalary());
}else return a;
}
比较器排序：Comparator
必须重写方法
Set<Student> set = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge();
}
});
set.add(new Student("李四",22,3000));
set.add(new Student("王五",29,33000));
set.add(new Student("赵六",20,23000));
System.out.println(set);
实现Comparable和实现Comparator区别:
1.实现Comparable在实体类中实现，方便创建异常排序条件，多次使用。
2.实现Comparable排序条件固化，不便于条件的改变
3.实现Comparator可以在每次创建对象使用时，重写排序条件，较为复杂，不利于多次使用
4.实现Comparator排序条件灵活，便于条件的随时改变。
六，可变参数
如果定义方法，要求要在该方法中传入多个数据（未知)。
1.数组
2.集合
3.可变参数
public void 方法名(数据类型...参数名){
}
注意:
1.可变参数的本质就是数组
2.一个方法中有且仅有一个可变参数
3.如果有多个参数，可变参数只能是多个参数中的最后一个位置定义
public static void at(double b ,int ... a){
for(int in:a){
System.out.println(in);
}
System.out.println("----");
}
public static void main(String[] args) {
AA.at(1);
AA.at(23);
AA.at(1,2,3,4,5,6,7,8,9);
int a[]={11,22,33};
AA.at(1,a);
}
七，Collections工具类
Collections是一个类似于Arrays的工具类, Arrays工具类提供了各种操作数组的方法, Collections工具类提供了各种操作集合的方法.
Collections类提供了向集合中添加元素,对集合排序,二分查找元素,列表拷贝,列表填充元素,获取列表最大/最小值,替换列表元素,
// 创建一个list集合，向其中加入6个数据
List<Integer> list = new ArrayList<Integer>();
// Collections -- addAll
Collections.addAll(list, 111, 2, 3, 4, 5);
System.out.println(list);
Collections.sort(list,new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1-o2;
}
});
System.out.println(list);
// 二分查找法
int index = Collections.binarySearch(list, 2);
System.out.println(index);
// 求极值
System.out.println(Collections.max(list));
System.out.println(Collections.min(list));
//替换
Collections.replaceAll(list,111,123);
System.out.println(list);
// 翻转
Collections.reverse(list);
System.out.println(list);
// 打乱数据
Collections.shuffle(list);
System.out.println(list);
// 填充其他数据
Collections.fill(list,1000);
System.out.println(list);
八，Map
Map不同于Collection，它是存储键值对的容器，键就像List的下标，可以通过键找到对应的值。Map中key不能重复。
Map接口也是Map集合，是键值对集合，键是唯一的，不可重复；值不唯一的，可以重复的。
九，HashMap实现类
HashMap:是最普通的Map实现类，键值对的顺序是无序的。
Map map = new HashMap();
map.put("11","zxl");
map.put("22","xly");
map.put("11","ZXL"); //如果key重复了，则会覆盖数据
System.out.println(map.size());
System.out.println(map.isEmpty());
System.out.println(map);
System.out.println(map.get("11"));
map.remove("11");
System.out.println(map);
System.out.println(map.containsKey("22"));
System.out.println(map.containsValue("zxl"));
遍历
- keySet
- entrySet
- values
// 创建对象
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1001,"zxl");
map.put(1002,"xly");
map.put(1003,"zzz");
map.put(1004,"xxx");
System.out.println(map);
// 遍历
// 方式一: 使用keySet方式
// 加强for循环
Set<Integer> keys = map.keySet();
for (Integer key : keys) {
System.out.println(key+" "+map.get(key));
}
System.out.println("================");
// 迭代器
Iterator<Integer> iterator = keys.iterator();
while (iterator.hasNext()) {
Integer key = iterator.next();
System.out.println(key+" "+map.get(key));
}
System.out.println("=================");
// 方式二： 使用entrySet方式来获取
// 加强for循环
Set<Map.Entry<Integer, String>> ens = map.entrySet();
for (Map.Entry<Integer, String> entry : ens) {
System.out.println(entry.getKey()+"="+entry.getValue());
}
// 迭代器
Iterator<Map.Entry<Integer, String>> iterator2 = ens.iterator();
while (iterator2.hasNext()) {
Map.Entry<Integer, String> entry2 = iterator2.next();
System.out.println(entry2.getKey()+"="+entry2.getValue());
}
// 方式三：只能获取values值
// 加强for循环
Collection<String> values = map.values();
for(String s:values){
System.out.println(s);
}
// 迭代器
Iterator<String> iterator3 = values.iterator();
while(iterator3.hasNext()){
System.out.println(iterator3.next());
}
扫一扫
973
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
