14_集合框架(续)

最新推荐文章于 2021-07-09 23:14:38 发布
最新推荐文章于 2021-07-09 23:14:38 发布
阅读量242 收藏
点赞数
分类专栏： Java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45044194/article/details/98088053
版权

百知教育 - 孙帅 - 14_集合框架(续)

13_List的排序

  • 代码：
    package day16;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Comparator;
public class TestSort1{
 public static void main(String[] args){
  /*
  List<String> list = Arrays.asList("abc","xya","xsji","sji","jjo");
  Collections.sort(list);
  
  for(String s : list){
   System.out.println(s);
  } 
  */ 
  List<Student> list = Arrays.asList(
   new Student("YKY",20),
   new Student("LYH",20),
   new Student("HHH",19),
   new Student("YXM",18)
  );
  Comparator<Student> c1 = new Comparator<Student>(){
   //if o1<o2 return 负数
   //if o1==o2 return 0
   //if o1>o2 reutrn 正数
   public int compare(Student o1, Student o2){
    return o1.age - o2.age;
   }
  }; 
  Comparator<Student> c2 = new Comparator<Student>(){
   public int compare(Student o1, Student o2){
    return o1.name.compareTo(o2.name);
   }
  };
  if(true) Collections.sort(list, c1);
  else Collections.sort(list, c2);
  for(Student s : list){
   System.out.println(s);
  }
 }
}
class Student implements Comparable<Student>{
 String name;
 int age;
 public Student(String name, int age){
  this.name = name;
  this.age = age;
 }
 @Override
 public String toString(){
  return "String [name="+name+", age="+age+"]";
 }
 @Override
 public int compareTo(Student o){
  return this.name.compareTo(o.name);
 }
}
  • 运行结果：
    在这里插入图片描述

14_JDK8中对List的排序

  • 排序
    1. Collections.sort(List):要求集合中的元素实现Comparable接口
    2. Collections.sort(List, Comparator):Comparator 比较器，实现排序逻辑；集合中的元素不需要实现Comparable接口
    3. list.sort(Comparator):直接对list调用sort方法排序，只能传入Comparator;是JDK8中的方法
  • 代码：
    package day16;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Comparator;
public class TestStringSort{
 public static void main(String[] args){
  List<String> list = Arrays.asList("一","四","六","七","三");
  
  Comparator<String> c1 = Comparator.naturalOrder();  //自然规则<==>Collections.sort(list);
  Comparator<String> c2 = c1.reversed();
  Comparator<String> c3 = new Comparator<String>(){
   List<String> list = Arrays.asList("一","二","三","四","五","六","七","八","九");
   public int compare(String s1, String s2){
    return list.indexOf(s1)-list.indexOf(s2);
   }
  };
  Comparator<String> c4 = c3.reversed();
  list.sort(c4);
  
  
  for(String s : list){
   System.out.println(s);
  }
 }
}
  • 运行结果：
    在这里插入图片描述

15_Set介绍

  • Set接口的特点：
    用于存放任意Object对象，无序、无下标、元素不能重复
  • Set接口中的方法：
    只有 从Collection 父接口中 继承到 的所有方法
  • 实现类：
    HashSet【重点】
  • Set遍历：
    1. 迭代器遍历 Collection 可以通过迭代器，删除集合中的元素
    2. for-each Collection JDK5
    3. foreach() 方法 需要实现 java.util.function.Consumer接口 来自JDK8
  • 代码：
    package day17;
import java.util.HashSet;
import java.util.Set;
import java.util.Iterator;
import java.util.Collection;
import java.util.function.Consumer;
public class TestHashSet{
 public static void main(String[] args){
  Set<String> s = new HashSet<>();
  s.add(new String("YKY"));
  s.add(new String("LYH"));
  s.add(new String("HHH"));
  s.add(new String("YXM"));
  s.add(new String("YKY"));
  
  //System.out.println(s.size());
  //print
  print1(s);
  System.out.println("-------------");
  print2(s);
  System.out.println("-------------");
  print3(s);
 }
 /*
 static void print(Collection<String> c){
  Iterator<String> it = c.iterator();
  while(it.hasNext()){
   String str = it.next();
   System.out.println(str);
  }
 }
 */
 static <T> void print1(Collection<T> c){
  Iterator<T> it = c.iterator();
  while(it.hasNext()){
   T t = it.next();
   System.out.println(t);
  }
 }
 static <T> void print2(Collection<T> c){
  for(T t : c){
   System.out.println(t);
  }
 }
 static <T> void print3(Collection<T> c){
  c.forEach(new Consumer<T>(){
   public void accept(T t){
    System.out.println(t);
   }
  });
 }
}
  • 运行结果：
    在这里插入图片描述

16_HashSet中的哈希算法

  • HashSet（保证内容重复对象只有一个）
    1. 覆盖 hashCode() 方法，保证 相同对象返回相同的int，尽可能 保证 不同对象返回不同的int
    2. 覆盖 equals() 方法，保证 相同对象返回true
  • 代码:
    package day17;
import java.util.HashSet;
import java.util.Set;
import java.util.Iterator;
import java.util.Collection;
import java.util.function.Consumer;
public class TestHashSet{
 public static void main(String[] args){
  Set<Student> s = new HashSet<>();
  s.add(new Student("YKY", 15));
  s.add(new Student("LYH", 19));
  s.add(new Student("HHH", 19));
  s.add(new Student("YXM", 18));
  s.add(new Student("YKY", 15));
  
  print1(s);
  //System.out.println("-------------");
  //print2(s);
  //System.out.println("-------------");
  //print3(s);
 }
 /*
 static void print(Collection<String> c){
  Iterator<String> it = c.iterator();
  while(it.hasNext()){
   String str = it.next();
   System.out.println(str);
  }
 }
 */
 static <T> void print1(Collection<T> c){
  Iterator<T> it = c.iterator();
  while(it.hasNext()){
   T t = it.next();
   System.out.println(t);
  }
 }
 static <T> void print2(Collection<T> c){
  for(T t : c){
   System.out.println(t);
  }
 }
 static <T> void print3(Collection<T> c){
  c.forEach(new Consumer<T>(){
   public void accept(T t){
    System.out.println(t);
   }
  });
 }
}
class Student{
 String name;
 int age;
 
 public Student(String name, int age){
  this.name = name;
  this.age = age;
 }
 @Override
 public String toString(){
  return "Student [name="+name+",age="+age+"]";
 }
 @Override
 public boolean equals(Object o){
  if(this == o) return true;
  if(o == null) return false;
  if(this.getClass() != o.getClass()) return false;
  Student s = (Student)o;
  if(this.name.equals(s.name) && this.age == s.age) return true;
  else return false;
 }
 @Override
 public int hashCode(){
  return age;
 }
}
  • 运行结果：
    在这里插入图片描述

17_HashSet中的高级哈希算法

  • eclipse中可自动生成较优的HashCode方法
  • 代码(见上代码)：
     @Override
 public int hashCode(){
  //return age+name.hashCode();
  
  //eclipse自动生成的hashCode实现代码
  final int prime = 31;
  int result = 1;
  result = prime * result + age;
  result = prime * result + ((name == null) ? 0 : name.hashCode());
  return result;
 }

18_Set的其他实现类

  • LinkedHashSet
    • 是HashSet的子类
    • 维护元素添加到Set中的顺序
  • 代码：
    package day17;
import java.util.LinkedHashSet;
import java.util.Set;
public class TestLinkedHashSet{
 public static void main(String[] args){
  Set<String> s = new LinkedHashSet<>();
  s.add("YKY");
  s.add("LYH");
  s.add("YXM");
  s.add("HHH");
  s.add("WKY");
  s.add("YKY");
  
  for(String s1 : s){
   System.out.println(s1);
  }
 }
}
  • 运行结果：

    在这里插入图片描述

  • TreeSet
    • 是Set的子接口SortedSet的实现类
    • 自动实现对元素的排序
    • 依照排序规则判断重复对象
  • 代码：
    package day17;
import java.util.Set;
import java.util.TreeSet;
import java.util.Comparator;
public class TestTreeSet{
 public static void main(String[] args){
  Comparator<Worker> c = new Comparator<Worker>(){
   /*
   if(w1<w2) return 负数
   if(w1>w2) return 正数
   if(w1==w2) return 0
   */
   public int compare(Worker w1, Worker w2){
    if(w1.age != w2.age) return w1.age - w2.age;
    else return w1.name.compareTo(w2.name);
   }
  };
  Set<Worker> s = new TreeSet<>(c);
  s.add(new Worker("YKY", 20));
  s.add(new Worker("YXM", 19));
  s.add(new Worker("ZYK", 19));
  s.add(new Worker("HHH", 17));
  s.add(new Worker("LYH", 18));
  s.add(new Worker("YKY", 20));
  
  for(Worker w : s){
   System.out.println(w);
  }
 }
}
class Worker{
 String name;
 int age;
 
 public Worker(String name, int age){
  this.age = age;
  this.name = name;
 }
 
 @Override
 public String toString(){
  return "Worker [name="+name+",age="+age+"]";
 }
 
}
  • 运行结果：

    在这里插入图片描述

19_Queue接口

  • Queue：
    • 队列
    • FIFO
  • 常用方法：
    1. add(): 添加元素
    2. offer(): 添加元素 优先使用
    3. remove(): 删除元素
    4. poll(): 删除元素 优先使用
    5. element(): 获取队列的头元素
    6. peek(): 获取队列的头元素 优先使用
  • 实现类：
    LinkedList
  • 代码：
    package day17;
import java.util.LinkedList;
import java.util.Queue;
public class TestQueue{
 public static void main(String[] args){
  Queue<String> q = new LinkedList<>();
  q.offer("YKY");
  q.offer("LYH");
  q.offer("HHH");
  
  //System.out.println(q.peek());
  String s1 = q.poll();
  String s2 = q.poll();
  String s3 = q.poll();
  System.out.println(s1);
  System.out.println(s2);
  System.out.println(s3);
  System.out.println(q.size());
 }
}
  • 运行结果：
    在这里插入图片描述

20_Map的基本特点和遍历

  • 基本特点：
    • 元素是 key-value
    • key无顺序，不可重复
    • value无顺序，可重复
  • 常用方法：
    1. get(Object key): 通过key查找对应的value
    2. put(Object key, Object value): 将key-value添加到Map中，如果key已存在，新的value覆盖旧的value
    3. remove(Object key): 删除key所对应的key-value对
    4. size(): 长度
    5. containsKey(Object key): 判断key是否存在
    6. containsValue(Object value): 判断value是否存在
  • 遍历：
    1. keySet(): 返回Set，遍历Map中所有的key
    2. values(): 返回Collection，遍历Map中所有的value
    3. entrySet(): 返回Set，Set中的元素为Map.Entry对象，代表了一个键值对
  • 代码：
    package day17;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Collection;
public class TestMap{
 public static void main(String[] args){
  Map<Integer, String> map = new HashMap<>();
  map.put(2008 , "北京");
  map.put(2012 , "伦敦");
  map.put(2016 , "里约热内卢");
  map.put(2020 , "东京");
  map.put(2024 , "巴黎");
  map.put(2028 , "洛杉矶");
  map.put(2004 , "雅典");
  map.put(2000 , "悉尼");
  map.put(1996 , "亚特兰大");
  map.put(1992 , "巴塞罗那");
  map.put(1988 , "首尔");
  map.put(1984 , "洛杉矶");
  map.put(1980 , "莫斯科");
  
  /*
  String s = map.get(2008);
  System.out.println(s);
  System.out.println(map.containsKey(1996));
  System.out.println(map.containsValue("东京"));
  */
  
  /*
  Set<Integer> keys = map.keySet();
  for(Integer key : keys){
   String value = map.get(key);
   System.out.println(key+"  ---  "+value);
  }
  */
  //print1(map);
  //print2(map);
  print3(map);
 }
 static <K, V> void print1(Map<K, V> map){
  Set<K> keys = map.keySet();
  for(K key : keys){
   V value = map.get(key);
   System.out.println(key+"  ---  "+value);
  }
 }
 static <K, V> void print2(Map<K, V> map){
  Collection<V> values = map.values();
  for(V value : values){
   System.out.println(value);
  }
 }
 static <K, V> void print3(Map<K, V> map){
  Set<Map.Entry<K, V>> set = map.entrySet();
  for(Map.Entry<K, V> me : set){
   K key = me.getKey();
   V value = me.getValue();
   System.out.println(key+"  ---  "+value);
  }
 }
}
  • 运行结果：
    在这里插入图片描述

21_JDK8中的Map遍历

  • forEach()
    实现 BiConsumer接口 ，直接遍历Map
  • 代码(见上代码)：
    static <K, V> void print4(Map<K, V> map){
  map.forEach(new BiConsumer<K, V>(){
   public void accept(K key, V value){
    System.out.println(key+"  ---  "+value);
   }
  });
 }

22_Map的实现类

  • HashMap：
    依靠 哈希算法 保证key不重复，JDK1.2、线程不安全、并发效率高、允许用null作为key或value
  • Hashtable(注意t小写):
    JDK1.0、线程安全、并发效率低、不允许用null作为key或value
  • LinkedHashMap：
    HashMap的子类，维护元素添加 到集合中的 顺序
  • TreeMap：
    是 Map的子接口SortedMap的实现类，自动对key排序
  • Properties：
    Hashtable的子类，key和value都是String，通常用于 配置文件的处理

23_里氏代换原则

  • 定义：
    在定义继承关系时要 满足is a关系，具体的应用场景为，针对父类说一句话，把父类替换成子类，这句话要依然成立。

24_不同版本的ArrayList初始长度

  • JDK8 初始长度为0（API文档是错的）
  • JDK6 初始长度为10
  • 学习时可以看Java实现源代码（最准确）
cherishIntention
关注
专栏目录
【GameFramework框架】四、GameFramework框架内置模块
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
02-05 2911
【GameFramework框架内置模块】1、全局配置（Config）【GameFramework框架内置模块】2、数据节点（Data Node）【GameFramework框架内置模块】3、数据表（Data Table）【GameFramework框架内置模块】4、调试器（Debugger）【GameFramework框架内置模块】5、下载（Download）【GameFramework框架内置模块】6、实体（Entity）【GameFramework框架内置模块】7、事件（Event）
一些安卓开源框架整理
我们的征途是星辰大海
10-03 2008
-----------------------分割线---------------------------------------------------------------------------------------------------------------------         为了提高开发效率，整理了一些安卓中的开源框架。-----------------------分割
14_集合框架
m0_45044194的博客
08-01 259
百知教育 - 孙帅 - 14_集合框架 01_集合的概念 集合： 是一种工具类，是对象的容器，可以用于存储数量不等的多个对象的对象，代替数组 所有集合的接口和相关实现类都在java.util包中 底层结构： 数组 代码： package day15; import java.util.Arrays; public class TestMyList{ public static voi...
17_IO 编程
m0_45044194的博客
08-08 214
百知教育 - 孙帅 - 17_IO 编程 01_IO流的概念和分类 流 流就是内存与存储设备之间 传输数据 的通道、管道。 IO流的分类 按方向（以JVM虚拟机为参照物）【重点】 输入流： 将<存储设备>中的内容 读入 到<内存>中。 输出流： 将<内存>中的内容 写入 到<存储设备>中。 按单位 字节流： 以字节为单位，可以操作 所...
20_Lambda表达式与Stream编程
m0_45044194的博客
08-20 228
百知教育 - 孙帅 - 20_Lambda表达式与Stream编程 01_Java8中的接口 接口的新语法： 接口和工具类 Collection和Collections Executor和Executors 接口的静态方法 Comparator接口 接口的默认方法 接口版本的向后兼容 代码： package day26; import java.util.Comparato...
❤有学妹问我Java架构师怎么入门，我甩出12k亲身体验的学习视频推荐给她
XiaoLin
07-09 1万+
序言 又到了一年一度的高考选专业的日子，我大学的专业是计算机科学与技术，很多的粉丝或者亲朋好友会问我：你这个专业怎么样呀，怎么入门呀，我的回答一般都是B站自学，这个也确实是，因为在大学老师教的东西很多都是过时的东西了，基本上企业里面也很少用到，我大学期间都是自己一个人在B站上自学的，也积累了很多的经验，知道哪些课程好，哪些课程适合小白，下面我会给出自己觉得还不错的课程，一个是二选一（全程无任何恰饭），顺序就是整个学习计划，包括了基础、进阶、项目、前端、运维等知识，喜欢的小伙伴可以给个一键三连！ IDEA使用
16_多线程
m0_45044194的博客
08-06 217
百知教育 - 孙帅 - 16_多线程 01_线程的概念和实现线程的方式 什么是进程 程序是静止的，只有真正运行时的程序，才被称为进程。 单核CPU在任何时间点上，只能运行一个进程；宏观并行、微观串行。 什么是线程 线程，又称为 轻量级进程（Light Weight Process）。 是程序中的 一个顺序控制流程，同时也是 CPU的基本调度单位。进程由多个线程组成，彼此间完成不同的工...
iOS框架集合：
Onlyone的博客
07-27 914
点击查看：<精华篇>：iOS视频大全-持续更新上下拉刷新控件1.MJRefresh–仅需一行代码就可以为UITableView或者CollectionView加上下拉刷新或者上拉刷新功能。可以自定义上下拉刷新的文字说明。（推荐）2.SVPullToRefresh–下拉刷新控件4500+star，值得信赖3.CBStoreHouseRefreshControl–一个效果很酷炫的下拉刷新控件3600+s
iOS第三方框架集合
努力，可能成功！放弃，注定失败！
03-18 1679
在iOS开发中不可避免的会用到一些第三方类库，它们提供了很多实用的功能，使我们的开发变得更有效率；同时，也可以从它们的源代码中学习到很多有用的东西。 Reachability 检测网络连接 用来检查网络连接是否可用：包括WIFI和WWAN(3G/EDGE/CDMA等)两种工作模式。 现在有更好的替代品：https://github.com/tonymillion/Reachability，比
Android 常用六大框架
06-01
(9) 下载器模块:可以简单的实现多线程下载、后台下载、断点续传、对下载进行控制、如开始、暂停、删除等等。 (10) 网络状态检测模块：当网络状态改变时，对其进行检 6、LoonAndroid 项目地址：...
"pycity_pycing-基于优化的城市多能源电力调度算法的Python框架（软件X 16）
软件X 16（2021）100839原始软件出版物pycity_pycing-一个Python框架，用于开发和评估城市地区多能源系统的基于优化的电力调度算法SebastianSchwarz，Sebastian Alexander Uerlich，Antonello Monti复杂电力系统自动...
08_面向对象的三大特性
m0_45044194的博客
07-07 172
百知教育 - 孙帅 - 08_面向对象的三大特性 01_封装 概念： 尽可能 隐藏 对象内部实现细节，控制 对象的修改及访问的 权限。 访问修饰符： private（可将属性修饰为 私有 ，仅本类可见） 公共访问方法： 作用： 提供公共访问方法，以保证数据的 正常录入。 命名规范： 赋值：setXXX() //使用方法返回值实现赋值 取值：getXXX() //使用方法返回值实现取值...
11_内部类
m0_45044194的博客
07-28 178
百知教育 - 孙帅 - 11_内部类 01_内部类概述 概念： 在一个类的内部再定义一个完整类 特点（编译时类型：运行时，用到哪个类就加载哪个类，不分内外）： 编译之后分别生成独立的字节码文件。 内部类可直接访问外部类的私有成员，而不破坏封装。 可为外部类提供必要的内部功能组件。 分类： 成员内部类、静态内部类、局部内部类、匿名内部类 代码（编译通过）： package day13...
chapter 01习题
m0_45044194的博客
05-20 1745
百知教育学习 - 胡鑫喆 - chapter 01习题 1. （标识符命名）下面几个变量中，哪些是对的？哪些是错的？错的请说明理由 A.ILoveJava B.$20 C.learn@java D.antony.lee E.Hello_World F.2tigers 代码/* * A right * B right * C wrong --> @ 不能出...
chapter 03函数习题
m0_45044194的博客
05-20 444
百知教育学习 - 胡鑫喆 - chapter 03函数习题 题目链接 提取码：nxo0 1.代码 package chapter_03; import java.util.*; public class Practice_03_01{ public static void main(String[] args) { Scanner s = new Scanner(System.in); ...
chapter 02循环结构习题
m0_45044194的博客
05-20 432
百知教育学习 - 胡鑫喆 - chapter 02循环结构习题 题目链接 提取码：a53a 1.代码 package chapter_02; public class Practice_02_01{ public static void main(String[] args) { int sum = 0; for(int i = 1; i < 101; i++) { su...
chapter 04 数组
m0_45044194的博客
06-05 312
百知教育学习 - 胡鑫喆 - chapter 04 数组 题目链接 提取码：h008 1、代码 package chapter_04; public class Practice_04_01{ public static void main(String[] args) { /* A 正确 * B 正确 * C 错误 --> int[] a = {1,2,3,4,5};...
循环与分支结构
m0_45044194的博客
05-19 308
百知教育学习 - 胡鑫喆 - 循环与分支结构 一、if选择结构与分支结构 if 语法 if（布尔表达式） { 代码块 } 在java中if的条件中只能写布尔表达 式，不能写整数表达式。 代码package day3; import java.util.Scanner; public class TestIf{ public static void main(String[] args){ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值