5.11 泛型Generic ,Map接口
容器(Collection)
泛型(Generic)(JDK1.5之后才有泛型)
1, 装入集合的类型都被当作Object对待, 从而失去了自己的实际类型
2, 集合中秋出来的时候需要转型, 效率低, 易出错
好处: 增强程序的可读性和稳定性
注意: <>中定义的类型一定是引用类型 !!!
键:就是你存的值的编号
值:就是你要存放的数据
泛型写法
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 接口 :< >必须存两个类型
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方法
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 方法 通过一个箭去取一个值
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 用法 有两种方法
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 判断是否包含某个值
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 把值封装成一个集合
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 } }
一道题
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,
下边是第二种方法 /* 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循环
for (String s1 : set1) { System.out.println(s1); } /* * 好处: *简单方便, 效率高 * * 不能使用索引 * 不能通过变量来改变集合中的元素 * */
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(), 不能与父类的方法混着用
用法举例
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();
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排序
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; 小于返回负整数 } }
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 阅读(206) 评论(0) 编辑 收藏 举报