Java ——集合框架 list lambda set map 遍历方法 数据结构
本节重点思维导图
有序无序：元素放入的顺序与取出的顺序是否一致，一致即为有序，不一致即无序。
- List：允许重复、有序
- ArrayList：长度可变的数组，遍历速度快
- LinkedList：链表：添加删除节点速度快
import java.util.ArrayList;
import java.util.Date;
import java.util.List; public class Demo {
public static void main(String[] args) {
List list = new ArrayList();
System.out.println("--------"+list.toString());//add
list.add("aa");
list.add(1234);
list.add(true);
list.add(new Date());
list.add(1234);
list.add(3.14); System.out.println(list.get(0) + " -- " + list.get(3));
System.out.println(list.size()); System.out.println(list);
System.out.println(list.toString()); for (Object obj : list) {
System.out.println(obj);
} list.remove(0);// 根据下标移除 list.clear();
System.out.println(list.size());
} }
结果：
--------[]
aa -- Fri May 31 15:07:45 CST 2019
6
[aa, 1234, true, Fri May 31 15:07:45 CST 2019, 1234, 3.14]
[aa, 1234, true, Fri May 31 15:07:45 CST 2019, 1234, 3.14]
aa
1234
true
Fri May 31 15:07:45 CST 2019
1234
3.14
0
泛型
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List; public class Demo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("1234");
list.add("true");
list.add("aaaa");
list.add("aaaa");
list.add("bbbb");
list.add("dddd"); String e3 = list.get(3);
System.out.println(e3);
System.out.println(list.get(3));
int size = list.size();
System.out.println(size); for (String item : list) {
System.out.println(item);
} System.out.println("--------------------------");
// Iterator迭代器
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {// 判断是否还有下一个元素，有的话返回true
String next = iterator.next();// 取出元素，同时将指针指向当前位置
System.out.println(next);
}
}
}
结果：
aaaa
aaaa
6
1234
true
aaaa
aaaa
bbbb
dddd
--------------------------
1234
true
aaaa
aaaa
bbbb
dddd
list\Lambda\set\map
*lambda
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("zhangsan");
list.add("lisi");
list.add("zhangsan");
list.add("wanger");
list.add("mazi");
list.add("wanger");
list.stream().forEach(element->System.out.println(element));
System.out.println();
list.forEach(item -> System.out.println(item));
System.out.println();
list.forEach(System.out::println);
//将List中所有的元素变成大写字母后再逆序输出
System.out.println();
for(int i =list.size()-1;i>=0;i--) {
String item = list.get(i);
item = item.toUpperCase();
System.out.println(item);
}
System.out.println();
list.stream().map(item->item.toUpperCase())//映射：依次拿出List中的每一个元素进行映射
.forEach(System.out::println);
//输出List中每一个元素的前两个字符
System.out.println();
list.stream().map(item->item.substring(0, 2))
.forEach(System.out::println);
//只输出List中长度大于4的元素
System.out.println();
list.stream().filter(item->item.length()>4)
.forEach(System.out::println);
//去除重复
System.out.println();
list.stream().distinct().forEach(System.out::println);
//将Stream转换成List
System.out.println();
List<String> collect = list.stream().collect(Collectors.toList());
System.out.println(collect);
}
*set
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("zhangsan");
set.add("lis");
set.add("zhangsan");
set.add("wanger");
set.add("mazi");
set.add("wanger");
for(String item : set) {
System.out.println(item);
}
System.out.println();
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println();
set.forEach(System.out::println);
}
示例：学习set判断元素是否相等
public class Dept {
private int deptno;
private String dname;
private String loc;
public Dept() {
super();
}
public Dept(int deptno, String dname, String loc) {
super();
this.deptno = deptno;
this.dname = dname;
this.loc = loc;
}
public int getDeptno() {
return deptno;
}
public void setDeptno(int deptno) {
this.deptno = deptno;
}
public String getDname() {
return dname;
}
public void setDname(String dname) {
this.dname = dname;
}
public String getLoc() {
return loc;
}
public void setLoc(String loc) {
this.loc = loc;
}
@Override
public int hashCode() {
return 234;
}
@Override
public boolean equals(Object obj) {
return true;
}
@Override
public String toString() {
return "Dept [deptno=" + deptno + ", dname=" + dname + ", loc=" + loc + "]";
}
}
public static void main(String[] args) {
Set<Dept> set = new HashSet<>();
set.add(new Dept());
set.add(new Dept());
set.add(new Dept(10,"sales","new york"));
set.add(new Dept(20,"research","chicago"));
System.out.println(set.size());
set.forEach(System.out::println);
}
*map
键值对
public static void main(String[] args) {
Map<String, Integer> data = new HashMap<>();
data.put("a", 1);
data.put("b", 2);
data.put("c", 3);
data.put("d", 4);
System.out.println(data.get("a"));
Set<String> keySet = data.keySet();
keySet.forEach(System.out::println);
Collection<Integer> values = data.values();
values.forEach(item->System.out.print(item+" "));
System.out.println();
Set<Entry<String, Integer>> entrySet = data.entrySet();
for(Entry<String, Integer> item: entrySet) {
System.out.println(item.getKey()+" "+item.getValue());
}
data.forEach((k,v)->System.out.println(k+" : "+v));;
}
遍历方法
快捷键：
代码格式化：ctrl+sfhit+f
自动提示：alt+?
抽取变量：alt+shift+L
复习总结
Arrays
public static void main(String[] args) {
String[] data = { "zhangsan", "lisi", "wanger", "mazi","qianwu","zhaoliu" };
List<String> asList = Arrays.asList(data);
System.out.println(asList);
System.out.println(data);
System.out.println(Arrays.toString(data));
int binarySearch = Arrays.binarySearch(data, "lisi");
System.out.println(binarySearch);
//对数组进行扩容
String[] copyOf = Arrays.copyOf(data, data.length + 4);
for (String item : copyOf)
System.out.println(item);
String[] copyOfRange = Arrays.copyOfRange(data, 2, 4);
System.out.println(Arrays.toString(copyOfRange));
String[] copyOf2 = Arrays.copyOf(data, data.length);
boolean equals = Arrays.equals(data,copyOf2);//比较两个数组的内容是否相等
System.out.println(equals);
boolean[] bol = new boolean[8];
System.out.println(Arrays.toString(bol));
Arrays.fill(bol,true);
System.out.println(Arrays.toString(bol));
Arrays.sort(data);
System.out.println(Arrays.toString(data));
System.out.println("--------------------");
//匿名内部类
Comparator<String> c = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.length()-o1.length();
}
};
Arrays.sort(data,c);
System.out.println(Arrays.toString(data));
data = new String[]{ "zhangsan", "lisi", "wanger", "mazi","qianwu","zhaoliu" };
Arrays.sort(data,(o1,o2)->o2.length()-o1.length());
System.out.println(Arrays.toString(data));
}
collections
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list,"zhangsan", "lisi","zhangsan","wanger","zhangsan","mazi");
System.out.println(list);
int binarySearch = Collections.binarySearch(list, "lisi3");
System.out.println(binarySearch);
int binarySearch2 = Collections.binarySearch(list, "wanger", (o1,o2)->o1.length()-o2.length());
System.out.println(binarySearch2);
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
});
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
Collections.sort(list, (o1,o2)->o1.length()-o2.length());;
System.out.println(list);
Collections.replaceAll(list, "zhangsan", "***");
System.out.println(list);
Collections.swap(list, 1, 3);
System.out.println(list);
Collections.reverse(list);
System.out.println(list);
}
list
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list,"zhangsan", "lisi","wanger","mazi");
for(int i =0;i<list.size();i++){
System.out.println(list.get(i));
}
for(String item : list){
System.out.println(item);
}
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
ListIterator<String> listIterator = list.listIterator();
while(listIterator.hasNext()){
System.out.println(listIterator.next());
}
list.forEach(item->System.out.println(item));
list.forEach(System.out::println);
}
set
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("aa");
set.add("bb");
set.add("cc");
set.add("dd");
for(String item : set){
System.out.println(item);
}
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
set.forEach(item->System.out.println(item));
set.forEach(System.out::println);
}
map
原则：将map变为set
public static void main(String[] args) {
Map<Integer,Goods> map = new HashMap<>();
map.put(111, new Goods(111,"aaa",1,"aaaaaaaaaaa"));
map.put(222, new Goods(222,"bbb",2,"bbbbbbbbbbbbb"));
map.put(333, new Goods(333,"ccc",3,"ccccccccccccc"));
map.put(444, new Goods(444,"ddd",4,"dddddddddddd"));
Set<Integer> keySet = map.keySet();
for(Integer key : keySet){
System.out.println(key+" : "+map.get(key));
}
Set<Entry<Integer, Goods>> entrySet = map.entrySet();
for(Entry<Integer, Goods> item : entrySet){
System.out.println(item.getKey()+" "+item.getValue());
}
map.forEach((k,v)->System.out.println(k+" :: "+v));;
}
扩展：
public static void main(String[] args) {
List<String> list = Arrays.asList("zhangsan","lisi","wanger","mazi");
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length() - o2.length();
}
});
System.out.println(list);
System.out.println("-------------");
list.forEach(item->System.out.println(item+" "+item.hashCode()));
list.sort((o1,o2)->{
return o1.hashCode()- o2.hashCode();
});
list.forEach(System.out::println);
}
Java ——集合框架 list lambda set map 遍历方法 数据结构的更多相关文章
- 自顶向下理解Java集合框架（三）Map接口
Map基本概念 数据结构中Map是一种重要的形式.Map接口定义的是查询表,或称查找表,其用于储存所谓的键/值对(key-value pair),其中key是映射表的索引. JDK结构中还存在实现Ma ...
- JAVA集合框架（三）-Map
前言 Map是java中用于存储键值对映射的接口.是解决编程问题最常用的数据结构之一.在工作中,有时候为实现一个功能可能写了好大一段代码,运行是ok了,但是就是不想回头再看,不敢相信自己写的这么烂.这 ...
- Java集合框架（五）—— Map、HashMap、Hashtable、Properties、SortedMap、TreeMap、WeakHashMap、IdentityHashMap、EnumMap
Map Map用于保存具有映射关系的数据,因此Map集合里保存着两组值,一组值用于保存Map里的key,另一组值用于保存Map里的value,key和value都可以是任何引用类型的数据.Map的ke ...
- Java集合框架的总结
本篇文章先从整体介绍了Java集合框架包含的接口和类,然后总结了集合框架中的一些基本知识和关键点,并结合实例进行简单分析.当我们把一个对象放入集合中后,系统会把所有集合元素都当成Object类的实例进 ...
- Java集合框架的知识总结（1）
说明:先从整体介绍了Java集合框架包含的接口和类,然后总结了集合框架中的一些基本知识和关键点,并结合实例进行简单分析. 1.综述 所有集合类都位于java.util包下.集合中只能保存对象(保存对象 ...
- Java集合框架的知识总结
说明:面试准备,写的挺不错的. 转载地址: http://www.cnblogs.com/zhxxcq/archive/2012/03/11/2389611.html 1.综述 所有集合类都位于jav ...
- [转]Java - 集合框架完全解析
数据结构是以某种形式将数据组织在一起的集合,它不仅存储数据,还支持访问和处理数据的操作.Java提供了几个能有效地组织和操作数据的数据结构,这些数据结构通常称为Java集合框架.在平常的学习开发中,灵 ...
- Java集合框架总结—超详细-适合面试
Java集合框架总结—超详细-适合面试 一.精简: A.概念汇总 1.Java的集合类主要由两个接口派生而出:Collection和Map,Collection和Map是Java集合框架的根接口, ...
- S2:java集合框架
Java集合就是一个容器.面向对象语言对事物的体现都是以对象的形式存在,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式.集合只用于存储对象,集合长度是可变的,集合可以 ...
随机推荐
- VMware 问题
桥接模式下,小鸡上不了网问题 多网卡导致的问题 解决:编辑-虚拟网络编辑器 选择vmnet0,然后点击右下角更改设置 把自动改为指定要桥接的网卡,然后点击确定,测试看看.
- 区块链共识算法|RAFT和PBFT的区别
这里有个很形象的比喻: 一个团队一定会有一个老大和普通成员.对于 raft 算法,共识过程就是:只要老大还没挂,老大说什么,我们(团队普通成员)就做什么,坚决执行.那什么时候重新老大呢?只有当老大挂了 ...
- zabbix简单的操作（添加主机）
zabbix是一种监控软件,我用的是centos7.5版本 Zabbix是一个基于WEB界面的提供分布式监视功能的企业级的开源解决方案. Zabbix既可以监控操作系统(Linux/Windows/A ...
- VS插件CodeRush for Visual Studio发布v19.1.5|新的Inline Lambda重构
CodeRush是一个强大的Visual Studio .NET 插件,它利用整合技术,通过促进开发者和团队效率来提升开发者体验.CodeRush能帮助你以极高的效率创建和维护源代码.Consume- ...
- Python之面向对象之初识面向对象
初始面向对象 一.面向过程:面向过程的程序设计的核心是过程(流水线式思维),过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西. 优点:极大地降低了写成学的复 ...
- HTTP协议的请求方法
HTTP概念: HTTP是一个基于TCP/IP通信协议来传递数据,包括html文件.图像.结果等,即是一个客户端和服务器端请求和应答的标准 1.http无连接:限制每次连接只处理一个请求,服务端完成客 ...
- JAVA笔记23-IO流（1）
一.流的概念和分类 JAVA程序中,对于数据的输入.输出操作以“流”(stream)方式进行:J2SDK提供了各种各样的“流”类,用以获取不同种类的数据:程序中通过标准的方法输入或输出数据. java ...
- hdu 3376 : Matrix Again【MCMF】
题目链接 题意:给定一个n*n的矩阵,找一条路,从左上角到右下角再到左上角,每个点最多经过一次,求路径上的点的权值的最大和. 将矩阵中每个点拆点,点容量为1,费用为点权值的相反数.每个点向自己右侧和下 ...
- vue - 登录验证与权限控制
描述具体问题 需求 业务系统通常需要登录才能访问受限资源,在用户未登录情况下访问受限资源需要重定向到登录页面: 多个业务系统之间要实现单点登录,即在一个系统或应用已登录的情况下,再访问另一个系统时不需 ...
- BigDecimal除法问题
BigDecimal类的主要功能是进行小数的大数计算,而且最重要的是可以精确到指定的四舍五入位数. 如果要进行四舍五入的操作,则必须依靠以下的方法:public BigDecimal divide(B ...