本节重点思维导图

集合框架

有序无序：元素放入的顺序与取出的顺序是否一致，一致即为有序，不一致即无序。

  • List：允许重复、有序
  • ArrayList：长度可变的数组，遍历速度快
  • LinkedList：链表：添加删除节点速度快
  1. import java.util.ArrayList;
  2. import java.util.Date;
  3. import java.util.List;
  4.  
  5. public class Demo {
  6.     public static void main(String[] args) {
  7.         List list = new ArrayList();
  8.         System.out.println("--------"+list.toString());//add
  9.         list.add("aa");
  10.         list.add(1234);
  11.         list.add(true);
  12.         list.add(new Date());
  13.         list.add(1234);
  14.         list.add(3.14);
  15.  
  16.         System.out.println(list.get(0) + "   --     " + list.get(3));
  17.         System.out.println(list.size());
  18.  
  19.         System.out.println(list);
  20.         System.out.println(list.toString());
  21.  
  22.         for (Object obj : list) {
  23.             System.out.println(obj);
  24.         }
  25.  
  26.         list.remove(0);// 根据下标移除
  27.  
  28.         list.clear();
  29.         System.out.println(list.size());
  30.     }
  31.  
  32. }

结果：

  1. --------[]
  2. aa   --     Fri May 31 15:07:45 CST 2019
  3. 6
  4. [aa, 1234, true, Fri May 31 15:07:45 CST 2019, 1234, 3.14]
  5. [aa, 1234, true, Fri May 31 15:07:45 CST 2019, 1234, 3.14]
  6. aa
  7. 1234
  8. true
  9. Fri May 31 15:07:45 CST 2019
  10. 1234
  11. 3.14
  12. 0

 泛型

  1. import java.util.ArrayList;
  2. import java.util.Date;
  3. import java.util.Iterator;
  4. import java.util.List;
  5.  
  6. public class Demo {
  7.     public static void main(String[] args) {
  8.                         List<String> list = new ArrayList<>();
  9.                         list.add("1234");
  10.                         list.add("true");
  11.                         list.add("aaaa");
  12.                         list.add("aaaa");
  13.                         list.add("bbbb");
  14.                         list.add("dddd");  
  15.  
  16.                         String e3 = list.get(3);
  17.                         System.out.println(e3);
  18.                         System.out.println(list.get(3));
  19.                         int size = list.size();
  20.                         System.out.println(size);  
  21.  
  22.                         for (String item : list) {
  23.                             System.out.println(item);
  24.                         }  
  25.  
  26.                         System.out.println("--------------------------");
  27.                         // Iterator迭代器
  28.                         Iterator<String> iterator = list.iterator();
  29.                         while (iterator.hasNext()) {// 判断是否还有下一个元素，有的话返回true
  30.                             String next = iterator.next();// 取出元素，同时将指针指向当前位置
  31.                             System.out.println(next);
  32.                         }
  33.                     }
  34. }

结果：

  1. aaaa
  2. aaaa
  3. 6
  4. 1234
  5. true
  6. aaaa
  7. aaaa
  8. bbbb
  9. dddd
  10. --------------------------
  11. 1234
  12. true
  13. aaaa
  14. aaaa
  15. bbbb
  16. dddd

list\Lambda\set\map

*lambda

  1. public static void main(String[] args) {
  2.         List<String> list = new ArrayList<>();
  3.         list.add("zhangsan");
  4.         list.add("lisi");
  5.         list.add("zhangsan");
  6.         list.add("wanger");
  7.         list.add("mazi");
  8.         list.add("wanger");
  9.  
  10.         list.stream().forEach(element->System.out.println(element));
  11.         System.out.println();
  12.         list.forEach(item -> System.out.println(item));
  13.         System.out.println();
  14.         list.forEach(System.out::println);
  15.  
  16.         //将List中所有的元素变成大写字母后再逆序输出
  17.         System.out.println();
  18.         for(int i =list.size()-1;i>=0;i--) {
  19.             String item = list.get(i);
  20.             item = item.toUpperCase();
  21.             System.out.println(item);
  22.         }
  23.         System.out.println();
  24.         list.stream().map(item->item.toUpperCase())//映射：依次拿出List中的每一个元素进行映射
  25.             .forEach(System.out::println);
  26.  
  27.         //输出List中每一个元素的前两个字符
  28.         System.out.println();
  29.         list.stream().map(item->item.substring(0, 2))
  30.             .forEach(System.out::println);
  31.  
  32.         //只输出List中长度大于4的元素
  33.         System.out.println();
  34.         list.stream().filter(item->item.length()>4)
  35.             .forEach(System.out::println);
  36.  
  37.         //去除重复
  38.         System.out.println();
  39.         list.stream().distinct().forEach(System.out::println);
  40.  
  41.         //将Stream转换成List
  42.         System.out.println();
  43.         List<String> collect = list.stream().collect(Collectors.toList());
  44.         System.out.println(collect);
  45.     }

*set

  1. public static void main(String[] args) {
  2.         Set<String> set  = new HashSet<>();
  3.         set.add("zhangsan");
  4.         set.add("lis");
  5.         set.add("zhangsan");
  6.         set.add("wanger");
  7.         set.add("mazi");
  8.         set.add("wanger");
  9.  
  10.         for(String item : set) {
  11.             System.out.println(item);
  12.         }
  13.  
  14.         System.out.println();
  15.         Iterator<String> iterator = set.iterator();
  16.         while(iterator.hasNext()) {
  17.             System.out.println(iterator.next());
  18.         }
  19.  
  20.         System.out.println();
  21.         set.forEach(System.out::println);
  22.     }

示例：学习set判断元素是否相等

  1. public class Dept {
  2.     private int deptno;
  3.     private String dname;
  4.     private String loc;
  5.  
  6.     public Dept() {
  7.         super();
  8.     }
  9.  
  10.     public Dept(int deptno, String dname, String loc) {
  11.         super();
  12.         this.deptno = deptno;
  13.         this.dname = dname;
  14.         this.loc = loc;
  15.     }
  16.  
  17.     public int getDeptno() {
  18.         return deptno;
  19.     }
  20.     public void setDeptno(int deptno) {
  21.         this.deptno = deptno;
  22.     }
  23.  
  24.     public String getDname() {
  25.         return dname;
  26.     }
  27.  
  28.     public void setDname(String dname) {
  29.         this.dname = dname;
  30.     }
  31.  
  32.     public String getLoc() {
  33.         return loc;
  34.     }
  35.  
  36.     public void setLoc(String loc) {
  37.         this.loc = loc;
  38.     }
  39.  
  40.     @Override
  41.     public int hashCode() {
  42.         return 234;
  43.     }
  44.  
  45.     @Override
  46.     public boolean equals(Object obj) {
  47.         return true;
  48.     }
  49.  
  50.     @Override
  51.     public String toString() {
  52.         return "Dept [deptno=" + deptno + ", dname=" + dname + ", loc=" + loc + "]";
  53.     }
  54. }
  55.  
  56.     public static void main(String[] args) {
  57.         Set<Dept> set = new HashSet<>();
  58.  
  59.         set.add(new Dept());
  60.         set.add(new Dept());
  61.         set.add(new Dept(10,"sales","new york"));
  62.         set.add(new Dept(20,"research","chicago"));
  63.  
  64.         System.out.println(set.size());
  65.  
  66.         set.forEach(System.out::println);
  67.     }

*map

键值对

  1. public static void main(String[] args) {
  2.         Map<String, Integer> data = new HashMap<>();
  3.         data.put("a", 1);
  4.         data.put("b", 2);
  5.         data.put("c", 3);
  6.         data.put("d", 4);
  7.  
  8.         System.out.println(data.get("a"));
  9.  
  10.         Set<String> keySet = data.keySet();
  11.         keySet.forEach(System.out::println);
  12.  
  13.         Collection<Integer> values = data.values();
  14.         values.forEach(item->System.out.print(item+" "));
  15.  
  16.         System.out.println();
  17.         Set<Entry<String, Integer>> entrySet = data.entrySet();
  18.         for(Entry<String, Integer> item: entrySet) {
  19.             System.out.println(item.getKey()+" "+item.getValue());
  20.         }
  21.  
  22.         data.forEach((k,v)->System.out.println(k+" : "+v));;
  23.     }

 

遍历方法

快捷键：

代码格式化：ctrl+sfhit+f

自动提示：alt+?

抽取变量：alt+shift+L

复习总结

Arrays

  1. public static void main(String[] args) {
  2.         String[] data = { "zhangsan", "lisi", "wanger", "mazi","qianwu","zhaoliu" };
  3.         List<String> asList = Arrays.asList(data);
  4.         System.out.println(asList);
  5.  
  6.         System.out.println(data);
  7.         System.out.println(Arrays.toString(data));
  8.  
  9.         int binarySearch = Arrays.binarySearch(data, "lisi");
  10.         System.out.println(binarySearch);
  11.  
  12.         //对数组进行扩容
  13.         String[] copyOf = Arrays.copyOf(data, data.length + 4);
  14.         for (String item : copyOf)
  15.             System.out.println(item);
  16.  
  17.         String[] copyOfRange = Arrays.copyOfRange(data, 2, 4);
  18.         System.out.println(Arrays.toString(copyOfRange));
  19.  
  20.         String[] copyOf2 = Arrays.copyOf(data, data.length);
  21.         boolean equals = Arrays.equals(data,copyOf2);//比较两个数组的内容是否相等
  22.         System.out.println(equals);
  23.  
  24.         boolean[] bol = new boolean[8];
  25.         System.out.println(Arrays.toString(bol));
  26.         Arrays.fill(bol,true);
  27.         System.out.println(Arrays.toString(bol));
  28.  
  29.         Arrays.sort(data);
  30.         System.out.println(Arrays.toString(data));
  31.  
  32.         System.out.println("--------------------");
  33.         //匿名内部类
  34.         Comparator<String> c = new Comparator<String>() {
  35.             @Override
  36.             public int compare(String o1, String o2) {
  37.                 return o2.length()-o1.length();
  38.             }
  39.         };
  40.  
  41.         Arrays.sort(data,c);
  42.         System.out.println(Arrays.toString(data));
  43.  
  44.         data = new String[]{ "zhangsan", "lisi", "wanger", "mazi","qianwu","zhaoliu" };
  45.         Arrays.sort(data,(o1,o2)->o2.length()-o1.length());
  46.         System.out.println(Arrays.toString(data));
  47.     }

collections

  1. public static void main(String[] args) {
  2.         List<String> list = new ArrayList<>();
  3.  
  4.         Collections.addAll(list,"zhangsan", "lisi","zhangsan","wanger","zhangsan","mazi");
  5.         System.out.println(list);
  6.  
  7.         int binarySearch = Collections.binarySearch(list, "lisi3");
  8.         System.out.println(binarySearch);
  9.  
  10.         int binarySearch2 = Collections.binarySearch(list, "wanger", (o1,o2)->o1.length()-o2.length());
  11.         System.out.println(binarySearch2);
  12.  
  13.         Collections.sort(list, new Comparator<String>() {
  14.             @Override
  15.             public int compare(String o1, String o2) {
  16.                 return o1.length()-o2.length();
  17.             }
  18.         });
  19.         System.out.println(list);
  20.  
  21.         Collections.shuffle(list);
  22.         System.out.println(list);
  23.  
  24.         Collections.sort(list, (o1,o2)->o1.length()-o2.length());;
  25.         System.out.println(list);
  26.  
  27.         Collections.replaceAll(list, "zhangsan", "***");
  28.         System.out.println(list);
  29.  
  30.         Collections.swap(list, 1, 3);
  31.         System.out.println(list);
  32.  
  33.         Collections.reverse(list);
  34.         System.out.println(list);
  35.     }

list

  1. public static void main(String[] args) {
  2.         List<String> list = new ArrayList<>();
  3.         Collections.addAll(list,"zhangsan", "lisi","wanger","mazi");
  4.  
  5.         for(int i =0;i<list.size();i++){
  6.             System.out.println(list.get(i));
  7.         }
  8.  
  9.         for(String item : list){
  10.             System.out.println(item);
  11.         }
  12.  
  13.         Iterator<String> iterator = list.iterator();
  14.         while(iterator.hasNext()){
  15.             System.out.println(iterator.next());
  16.         }
  17.  
  18.         ListIterator<String> listIterator = list.listIterator();
  19.         while(listIterator.hasNext()){
  20.             System.out.println(listIterator.next());
  21.         }
  22.  
  23.         list.forEach(item->System.out.println(item));
  24.  
  25.         list.forEach(System.out::println);
  26.     }

set

  1. public static void main(String[] args) {
  2.         Set<String> set = new HashSet<>();
  3.         set.add("aa");
  4.         set.add("bb");
  5.         set.add("cc");
  6.         set.add("dd");
  7.  
  8.         for(String item : set){
  9.             System.out.println(item);
  10.         }
  11.  
  12.         Iterator<String> iterator = set.iterator();
  13.         while(iterator.hasNext()){
  14.             System.out.println(iterator.next());
  15.         }
  16.  
  17.         set.forEach(item->System.out.println(item));
  18.  
  19.         set.forEach(System.out::println);
  20.     }

map

原则：将map变为set

  1. public static void main(String[] args) {
  2.         Map<Integer,Goods> map = new HashMap<>();
  3.         map.put(111, new Goods(111,"aaa",1,"aaaaaaaaaaa"));
  4.         map.put(222, new Goods(222,"bbb",2,"bbbbbbbbbbbbb"));
  5.         map.put(333, new Goods(333,"ccc",3,"ccccccccccccc"));
  6.         map.put(444, new Goods(444,"ddd",4,"dddddddddddd"));
  7.  
  8.         Set<Integer> keySet = map.keySet();
  9.         for(Integer key : keySet){
  10.             System.out.println(key+" : "+map.get(key));
  11.         }
  12.  
  13.         Set<Entry<Integer, Goods>> entrySet = map.entrySet();
  14.         for(Entry<Integer, Goods> item : entrySet){
  15.             System.out.println(item.getKey()+" "+item.getValue());
  16.         }
  17.  
  18.         map.forEach((k,v)->System.out.println(k+" :: "+v));;
  19.     }

扩展：

  1. public static void main(String[] args) {
  2.         List<String> list = Arrays.asList("zhangsan","lisi","wanger","mazi");
  3.  
  4.         Collections.sort(list, new Comparator<String>() {
  5.             @Override
  6.             public int compare(String o1, String o2) {
  7.                 return o1.length() - o2.length();
  8.             }
  9.         });
  10.  
  11.         System.out.println(list);
  12.  
  13.         System.out.println("-------------");
  14.         list.forEach(item->System.out.println(item+" "+item.hashCode()));
  15.  
  16.         list.sort((o1,o2)->{
  17.             return o1.hashCode()- o2.hashCode();
  18.         });
  19.         list.forEach(System.out::println);
  20.     }

Java ——集合框架 list lambda set map 遍历方法 数据结构的更多相关文章

  1. 自顶向下理解Java集合框架（三）Map接口

    Map基本概念 数据结构中Map是一种重要的形式.Map接口定义的是查询表,或称查找表,其用于储存所谓的键/值对(key-value pair),其中key是映射表的索引. JDK结构中还存在实现Ma ...

  2. JAVA集合框架（三）-Map

    前言 Map是java中用于存储键值对映射的接口.是解决编程问题最常用的数据结构之一.在工作中,有时候为实现一个功能可能写了好大一段代码,运行是ok了,但是就是不想回头再看,不敢相信自己写的这么烂.这 ...

  3. Java集合框架（五）—— Map、HashMap、Hashtable、Properties、SortedMap、TreeMap、WeakHashMap、IdentityHashMap、EnumMap

    Map Map用于保存具有映射关系的数据,因此Map集合里保存着两组值,一组值用于保存Map里的key,另一组值用于保存Map里的value,key和value都可以是任何引用类型的数据.Map的ke ...

  4. Java集合框架的总结

    本篇文章先从整体介绍了Java集合框架包含的接口和类,然后总结了集合框架中的一些基本知识和关键点,并结合实例进行简单分析.当我们把一个对象放入集合中后,系统会把所有集合元素都当成Object类的实例进 ...

  5. Java集合框架的知识总结（1）

    说明:先从整体介绍了Java集合框架包含的接口和类,然后总结了集合框架中的一些基本知识和关键点,并结合实例进行简单分析. 1.综述 所有集合类都位于java.util包下.集合中只能保存对象(保存对象 ...

  6. Java集合框架的知识总结

    说明:面试准备,写的挺不错的. 转载地址: http://www.cnblogs.com/zhxxcq/archive/2012/03/11/2389611.html 1.综述 所有集合类都位于jav ...

  7. [转]Java - 集合框架完全解析

    数据结构是以某种形式将数据组织在一起的集合,它不仅存储数据,还支持访问和处理数据的操作.Java提供了几个能有效地组织和操作数据的数据结构,这些数据结构通常称为Java集合框架.在平常的学习开发中,灵 ...

  8. Java集合框架总结—超详细-适合面试

    Java集合框架总结—超详细-适合面试   一.精简: A.概念汇总 1.Java的集合类主要由两个接口派生而出:Collection和Map,Collection和Map是Java集合框架的根接口, ...

  9. S2:java集合框架

    Java集合就是一个容器.面向对象语言对事物的体现都是以对象的形式存在,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式.集合只用于存储对象,集合长度是可变的,集合可以 ...

随机推荐

  1. 在VMware Vcenter添加一块网卡后，启动虚机找不到网卡，发现有一个ens38（redhat7.5）

    添加一块网卡后,启动虚机找不到网卡,发现有一个ens38 问题:新建虚拟机设置为一块网卡,时候在Vcenter再添加一块网卡,这个问题相信很多网友都见过,今天就来总结一下添加过程中的问题. 由于有以前 ...

  2. PIL 中的 Image 模块

    转载:http://www.cnblogs.com/way_testlife/archive/2011/04/20/2022997.html   PIL 中的 Image 模块 本文是节选自 PIL ...

  3. RSA前端加密

    昨天做了登陆模块,接触了md5&RSA加密.有点意思,talk is cheap,show me the code! 前端加密 为什么要加密 前端加密的方式 后台如何解密 1 为什么要加密? ...

  4. Spring：jar包详解

    org.springframework.aop ——Spring的面向切面编程,提供AOP(面向切面编程)的实现 org.springframework.asm——spring 2.5.6的时候需要a ...

  5. ZROI 19.08.10模拟赛

    传送门 写在前面:为了保护正睿题目版权,这里不放题面,只写题解. A \(20pts:\) 枚举操作序列然后暴力跑,复杂度\(O(6^n)\). \([50,80]pts:\) 枚举改成dfs,每层操 ...

  6. python 后台 安装 富文本编辑

    前言 当然需要安装一些后台只能输入一些文本编辑器,不然这样多少不美观呀 当然python 有 safe 可以把后台的标签转换 , 还有 striptags   这个是换成html 格式的,但不会加粗或 ...

  7. mysql的视图、索引、触发器、存储过程

    USE school; SELECT * FROM sc; SELECT * FROM course; SELECT * FROM student; SELECT * FROM teacher; -- ...

  8. 故障检测、性能调优与Java类加载机制

    故障检测.性能调优与Java类加载机制 故障检测.性能调优 用什么工具可以查出内存泄露 (1)MerroyAnalyzer:一个功能丰富的java堆转储文件分析工具,可以帮助你发现内存漏洞和减少内存消 ...

  9. SpringBoot的项目构建

    手动构建SpringBoot项目 一.手动构建一个Maven,选择...webapp或者选择快速骨架生成,然后命名并生成项目: 二.  在pom.xml中,进行三处配置: 设置父模块,子模块就可以继承 ...

  10. 为什么C++中只有指针和引用才能实现多态？

    代码: class A { public: virtual void Debug(){} }; class B:public A { public: virtual void Debug(){} }; ...