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 阅读(214) 评论(0) 编辑 收藏 举报
