5.11 泛型Generic ,Map接口
容器(Collection)
泛型(Generic)(JDK1.5之后才有泛型)
1, 装入集合的类型都被当作Object对待, 从而失去了自己的实际类型
2, 集合中秋出来的时候需要转型, 效率低, 易出错
好处: 增强程序的可读性和稳定性
注意: <>中定义的类型一定是引用类型 !!!
键:就是你存的值的编号
值:就是你要存放的数据
泛型写法
1 2 3 4 5 6 7 8 9 10 | import java.util.ArrayList; import java.util.List; public class Test2 { public static void main(String[] args) { List<Book> list = new ArrayList<Book>(); //< >里写什么,方法跟着一块变 list.add( new Book()); } } |
Map 接口 :< >必须存两个类型
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class Test2 { public static void main(String[] args) { Map<String,String> map = new HashMap<String, Object>(); //必须传两个类 Map<String, Object> map = new HashMap<String, Object>(); //Object是传什么类型都可以 map.put( "a" , "小明" ); map.put( "b" , new Book()); System.out.println(map); // 打印出b=Book name=null map.put( "c" , 123 ); map.put( "a" , 456 ); } } |
Map集合 的方法
put(有个返回值Object)
get
remove(也有个返回值)
containsKey
containsValue
size 指有几对
isEmpty 判断这个map集合是否为空
putAll 把另一个map集合里面的东西放到这个里面
clear 清空map集合里的内容,本身还存在
keySet---Set
values---Conllection
put方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class Test2 { public static void main(String[] args) { Map<String, Object> map = new HashMap<String, Object>(); Object o1 = map.put( "a" , "小明" ); Object o2 = map.put( "b" , new Book()); Object o3 = map.put( "c" , 123 ); Object o4 = map.put( "a" , 456 ); System.out.println(o1); System.out.println(o2); System.out.println(o3); System.out.println(o4); //以上会打印 null null null 小明 put 严格来讲不是往里添加,而是把原来的那个剑换成另一个值 一开始实例化一个Map对象的时候,是没有a,小明这个值的, 硬要获取值的话只能获取到 null ,这时候获取一下返回值o1, null 就会给o1,当新添加一个a的时候,原来的值就会返回来 } } |
get 方法 通过一个箭去取一个值
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class Test2 { public static void main(String[] args) { Map<String, Object> map = new HashMap<String, Object>(); Object o1 = map.put( "a" , "小明" ); Object o2 = map.put( "b" , new Book()); Object o3 = map.put( "c" , 123 ); Object o4 = map.put( "a" , 456 ); System.out.println(map.get( "c" )) //会打印出123 } } |
remove 用法 有两种方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class Test2 { public static void main(String[] args) { Map<String, Object> map = new HashMap<String, Object>(); Object o1 = map.put( "a" , "小明" ); Object o2 = map.put( "b" , new Book()); Object o3 = map.put( "c" , 123 ); Object o4 = map.put( "a" , 456 ); System.out.println(map.get( "c" )); map.remove( "c" ); map.remove( "a" , 456 ); //打印出b=Book name=null System.out.println(map); //打印出a=456,b=Book name=null Object o = map.remove( "c" ); //返回值 System.out.println(o); // 打印出123,就是把删掉的东西返回来了 Object o22 = map.remove( "a" , 456 ); //返回值 System.out.println(o22); //打印true,删除成功tru,失败false } } |
containsKey 用法 判断是否包含某个键 containValue 判断是否包含某个值
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class Test2 { public static void main(String[] args) { Map<String, Object> map = new HashMap<String, Object>(); Object o1 = map.put( "a" , "小明" ); Object o2 = map.put( "b" , new Book()); Object o3 = map.put( "c" , 123 ); Object o4 = map.put( "a" , 456 ); System.out.println(map.containsKey( "b" )); //打印true,说明有的 } } |
keySet---Set map里所有的键封装成了一个set集合 values---Conllection 把值封装成一个集合
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class Test2 { public static void main(String[] args) { Map<String, Object> map = new HashMap<String, Object>(); Object o1 = map.put( "a" , "小明" ); Object o2 = map.put( "b" , new Book()); Object o3 = map.put( "c" , 123 ); Object o4 = map.put( "a" , 456 ); Set<String> set1 = map.keySet(); System.out.println(set1); //打印出a,b,c Collection<Object> c = map.values(); System.out.println(c); //打印出456,Book name=null,123 } } |
一道题
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; public class Test3 { public static void main(String[] args) { String[] arrs = { "aa" , "bb" , "cc" , "dd" , "aa" , "cc" , "ee" , "ee" , "cc" , "aa" }; Map<String, Integer> map = new HashMap<>(); for ( int i = 0 ; i < arrs.length; i++) { map.put(arrs[i], map.get(arrs[i]) == null ? 1 : map.get(arrs[i]) + 1 ); 用三元运算符,等于空的时候是 1 ,不等于的时候+ 1 ,<br> 下边是第二种方法 /* Integer count = map.get(arrs[i]); if (count == null) { map.put(arrs[i], 1); } else { map.put(arrs[i], count + 1); } */ } System.out.println(map); } } |
加强版for循环
1 2 3 4 5 6 7 8 9 10 11 12 | for (String s1 : set1) { System.out.println(s1); } /* * 好处: *简单方便, 效率高 * * 不能使用索引 * 不能通过变量来改变集合中的元素 * */ |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; public class Test3 { public static void main(String[] args) { String[] arrs = { "aa" , "bb" , "cc" , "dd" , "aa" , "cc" , "ee" , "ee" , "cc" , "aa" }; List<String> list = new ArrayList<>(); list.add( "qqqq" );list.add( "wwww" );list.add( "eeee" ); Set<String> set = new HashSet<>(); set.add( "1111" );set.add( "22222222222" );set.add( "3333333" ); for (String s1 : arrs) { System.out.println(s1); //打印arrs } for (String s2 : list) { System.out.println(s2); //打印list } for (String s3 : set) { System.out.println(s3); // 打印set } } } |
Iterator接口
所有实现了Collection接口的容器都有一个iterator方法, 用来返回一个实现了Iterator接口的对象
Iterator对象称作迭代器, 用来方便的实现对容器内的元素的遍历
Iterator里面的三个方法:
hasNext() 有没有下一个,有的话返回下一个要遍历的元素
next(), 重点注意: 这个方法每调用一次, 游标就往下走一个
remove(), 不能与父类的方法混着用
用法举例
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.ListIterator; /** * 迭代器 * * @author Administrator */ public class Test4 { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add( "qqqq" ); list.add( "wwww" ); list.add( "eeee" ); list.add( "rrrr" ); Iterator<String> iter = list.iterator(); while (iter.hasNext()) { String s = iter.next(); System.out.println(s); if (s.equals( "wwww" )) { iter.remove(); //list.remove(iter.next()); 两个不能混用 } } System.out.println(list); } } |
Comparable接口, Collections类
List的常用算法:
sort(List); 排序
如果需要对自定义的类进行排序, 那就必须要让其实现Comparable接口, 实现比较两个类大小的方法
shuffle(List); 随机排列
void reverse(List); 逆序排列(Linked效率较高)]
copy(); 复制集合, 前提是size()大于等于源集合的size(长度, 和容量的区别)
fill(List, Object);使用某个对象填充整个List
binarySearch();
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | import java.util.ArrayList; import java.util.Collections; import java.util.List; /** * Collections * @author Administrator * */ public class Test5 { public static void main(String[] args) { // Arrays.sort // Collections. List<Integer> list = new ArrayList<Integer>(); list.add( 23 ); list.add( 47 ); list.add( 15 ); list.add( 9 ); list.add( 88 ); System.out.println(list); // Collections.sort(list); // 默认的从小到大 // Collections.shuffle(list); 随机排列 // Collections.reverse(list); 逆序排列,反转一下 List<Integer> list2 = new ArrayList<Integer>(); list2.add( 1 ); list2.add( 1 ); list2.add( 1 ); list2.add( 1 ); list2.add( 1 ); Collections.copy(list2, list); //需要传两个集合,前面是要复制的,后面是原集合 要复制的集合要大于等于 要复制的集合 System.out.println(list2); Collections.fill(list, 55 ); System.out.println(list);*/ //填充全部变成55了 Collections.sort(list); //必须先排序 int i = Collections.binarySearch(list, 9 ); 二分查找法 System.out.println(i); //排序之后打印0 } } |
如果list里装的是book,dog等对象,用comparable排序
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | public class Book implements Comparable<Book> { private String name; private double price; public Book() { super (); } public Book(String name, double price) { super (); this .name = name; this .price = price; } @Override public int compareTo(Book o) { if ( this .price > o.getPrice()) { 大于返回正整数 return 1 ; } if ( this .price == o.getPrice()) { 等于返回 0 return 0 ; } return - 1 ; 小于返回负整数 } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | import java.util.ArrayList; import java.util.Collections; import java.util.List; /** * Comparable * @author Administrator */ public class Test6 { public static void main(String[] args) { List<Book> list = new ArrayList<Book>(); list.add( new Book( "Java从入门到放弃" , 78 )); list.add( new Book( "Oracle数据库详解" , 56 )); list.add( new Book( "HTML入门" , 3 )); list.add( new Book( "三国演义" , 108 )); Collections.sort(list); //sort排序,因为是书所以没有标准排序所以要去自己写比较在上方代码红字 System.out.println(list); } } |
总结:
集合是数组的一种延伸, 与数组相比有很多好处和优点,
1, 可以存放不同的类型
2, 长度可变
3, 随时存放和获取
六个接口和一个类:
Collection
List
Set
Map
Iterator
Comparable
Collections工具类
选择一种集合类型是一件非常痛苦的事
在以后的编程中要考虑读取和修改的效率问题, 数据的存取在以后的使用过程中, Collection是主要的载体,
Array: 读快改慢
Linked: 读慢改快
Hash: 介于两者之间的
posted on 2018-05-11 16:20 sunyexiang 阅读(215) 评论(0) 编辑 收藏 举报
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步