16 集合
16.3 泛型
在引入范型之前,Java类型分为原始类型、复杂类型,其中复杂类型分为数组和类。引入范型后,一个复杂类型
就可以在细分成更多的类型。
例如原先的类型List,现在在细分成List, List等更多的类型。
格式:通过<>定义要操作的引用数据类型,其实<>就是用来接收类型的。
泛型类定义的泛型:在整个类中有效, 如果被方法使用,那么泛型的对象明确要操作的具体类型后,所有要操作的类型就已经固定。
静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。
泛型定义方法时<>放在修饰符后,返回值类型前。
例1:
public class GenericDemo {
public static void main(String[] args) {
Demo<Integer> d = new Demo<Integer>();
d.show(new Integer(2));
d.print(9);
Demo<String> s = new Demo<String>();
s.show("ssa");
s.print("asfdaf");
Demo.method("gabriel");
}
}
class Demo<T>{
public void show(T t){
System.out.println("show:"+t);
}
public<Q> void print(Q q){
System.out.println("print:"+q);
}
public static<W> void method(W w){
System.out.println("method:"+w);
}
}
运行结果:
例2:
public class GenericDemo {
public static void main(String[] args) {
InterImpl<Integer> i = new InterImpl<Integer>();
i.show(3);
}
}
interface Inter<T>{
void show(T t);
}
class InterImpl<T> implements Inter<T>{
public void show(T t){
System.out.println(t);
}
}
运行结果:3
通配符?,也可以理解为占位符。
16.4 Map接口
当数据之间存在映射关系时,可以使用map集合。
常用方法:
- 添加
value put(key,value):返回前一个和key关联的值,如果没有返回null。
- 删除
void clear():清空map集合。
value remove(Object key):根据指定的key删除这个键值对。 - 判断
boolean containsKey(key);
boolean containsValue(value);
boolean isEmpty(); - 获取
value get(key):通过键获取值,如果没有该键返回null。
当然可以通过返回null,来判断是否包含指定键。
int size():获取键值对个数。
- 删除
Map包含:
- Hashtable:底层是哈希表数据结构,不可以存入null键null值,该集合是线程同步的,jdk1.0,效率低;
- HashMap:底层是哈希表数据结构,允许使用null值和null键,该集合是不同步,jdk1.2,效率高。
TreeMap:底层是二叉树数据结构,线程不同步。可以用于给Map集合中的键进行排序。
例1:import java.util.Collection; import java.util.HashMap; import java.util.Map; public class MapDemo { public static void main(String[] args) { Map<String,String> map = new HashMap<String,String>(); //添加元素,同一个键后添加的值会覆盖原对应值,并返回原有值 System.out.println(map.put("1", "Gabriel1")); System.out.println(map.put("1", "Gabriel6")); map.put("2", "Gabriel2"); map.put("3", "Gabriel3"); System.out.println("containsKey:"+map.containsKey("1")); System.out.println("get:"+map.get("3")); System.out.println("remove:"+map.remove("1")); System.out.println(map); Collection<String> col = map.values(); System.out.println(col); } }
运行结果:
Map集合的取出方式:
1. map集合转成set集合(keySet()方法),再通过迭代器取出,如例2;
2. entrySet():将map集合中的映射关系存入到set集合中,而这个关系的数据类型就是Map.Entry,如例3。
例2:
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>();
map.put("2", "Gabriel2");
map.put("3", "Gabriel3");
map.put("1", "Gabriel1");
map.put("4", "Gabriel4");
Set<String> keySet = map.keySet();
Iterator<String> it = keySet.iterator();
while(it.hasNext()){
String key = it.next();
//有键后通过map集合的get方法获取其对应的值
String value = map.get(key);
System.out.println("key:"+key+"+value:"+value);
}
}
}
运行结果:
例3:
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>();
map.put("2", "Gabriel2");
map.put("3", "Gabriel3");
map.put("1", "Gabriel1");
map.put("4", "Gabriel4");
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while(it.hasNext()){
Map.Entry<String,String> me = it.next();
System.out.println(me.getKey()+".."+me.getValue());
}
}
}
运行结果:
例4:
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapTest {
public static void main(String[] args) {
HashMap<Student1,String> hm = new HashMap<Student1,String>();
hm.put(new Student1("Gabriel1",21), "上海");
hm.put(new Student1("Gabriel1",21), "南京");
hm.put(new Student1("Gabriel2",22), "北京");
hm.put(new Student1("Gabriel3",23), "广州");
hm.put(new Student1("Gabriel4",24), "杭州");
System.out.println("/*****第一种取出方式:********/");
Set<Student1> keySet = hm.keySet();
Iterator<Student1> it = keySet.iterator();
while(it.hasNext()){
Student1 stu = it.next();
String address = hm.get(stu);
System.out.println(stu+"..."+address);
}
System.out.println("/******第二种取出方式:*******/");
Set<Map.Entry<Student1, String>> entrySet= hm.entrySet();
Iterator<Map.Entry<Student1, String>> it1 = entrySet.iterator();
while(it1.hasNext()){
Map.Entry<Student1, String> me = it1.next();
System.out.println(me.getKey()+"..."+me.getValue());
}
}
}
class Student1 implements Comparable<Student1>{
private String name;
private int age;
Student1(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String toString(){
return name+":"+age;
}
//重写hashCode方法
public int hashCode() {
return name.hashCode()+age;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student1 other = (Student1) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public int compareTo(Student1 s) {
int num = new Integer(this.age).compareTo(new Integer(s.age));
if(num == 0)
return this.name.compareTo(s.name);
return num;
}
}
运行结果:
为何要重写hashCode()方法可参见:
http://blog.csdn.net/liushuai_ly/article/details/8197508
16.5 Arrays工具类
Arrays:集合框架的工具类,其中的方法均为静态。
16.5.1 数组变集合
Arrays中的asList(数组)将数组转换为集合,如例5。
例5:
import java.util.Arrays;
import java.util.List;
public class ArraysDemo {
public static void main(String[] args) {
String[] arr = {"abc","cc","xyz"};
List<String> list = Arrays.asList(arr);
boolean b = list.contains("ac");
System.out.println(b);
}
}
运行结果:false
P.S.
数组的长度是固定的,所以对于结合的增删方法是不可以使用的,否则,会发生UnsupportedOperationException。
如果数组中的元素都是对象,变成集合时,数组中的元素就直接转成集合中的元素。如果数组中的元素是基本数据类型,那么会将该数组作为集合中的元素存在,如例6。
例6:
import java.util.Arrays;
import java.util.List;
public class ArraysDemo {
public static void main(String[] args) {
String[] arr = {"abc","cc","xyz"};
List<String> list = Arrays.asList(arr);
/*boolean b = list.contains("ac");
System.out.println(b);*/
Integer[] nums = {1,3,2};
List<Integer> li = Arrays.asList(nums);
System.out.println(li);
}
}
运行结果:[1, 3, 2]
16.5.2 集合变数组
Collection接口中的toArray方法。
- 当指定类型的数组长度小于集合的size,则该方法内部会创建一个新的数组,长度为集合的size;
- 当指定类型的数组长度大于集合的size,则不会新创建数组,而是使用传递进来的数组,所以创建一个刚好的数组最优。
集合变数组是为了限制元素的操作,不需进行增删。
例7:
import java.util.ArrayList;
import java.util.Arrays;
public class CollectionToArray {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String> ();
al.add("a1");
al.add("a2");
al.add("a3");
String[] arr = al.toArray(new String[6]);
System.out.println(Arrays.toString(arr));
}
}
运行结果:[a1, a2, a3, null, null, null]
高级for循环:for(数据类型 变量名:被遍历的集合(Collection)或者数组){}
对集合进行遍历,只能获取集合元素,不能对集合进行操作。而迭代器
例8:
import java.util.ArrayList;
public class ForEachDemo {
public static void main(String[] args) {
ArrayList<String> arr = new ArrayList<String>();
arr.add("a1");
arr.add("a2");
arr.add("a3");
for(String s : arr){
s = "c";
System.out.println(s);
}
System.out.println(arr);
}
}
运行结果:
例9:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class ForEachDemo {
public static void main(String[] args) {
ArrayList<String> arr = new ArrayList<String>();
arr.add("a1");
arr.add("a2");
arr.add("a3");
for(String s : arr){
s = "c";
System.out.println(s);
}
System.out.println(arr);
int[] al = {1,3,4};
for(int i :al){
System.out.println("i:"+i);
}
HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1, "a");
hm.put(2, "b");
hm.put(3, "c");
Set<Integer> keySet = hm.keySet();
for(Integer i : keySet){
System.out.println(i+"::"+hm.get(i));
}
for(Map.Entry<Integer, String> me: hm.entrySet()){
System.out.println(me.getKey()+"---"+me.getValue());
}
}
}
运行结果:
方法的可变参数:
就是
在使用时注意,可变参数一定要定义在参数列表最后面
例10:
public class ParamMethodDemo {
public static void main(String[] args) {
show("a",1,2,3,4);
show("c",1,2,3,4,5);
}
public static void show(String a,int... arr){
System.out.print(arr.length+a);
}
}
运行结果:45ac
静态导入:
导入的该类中所有静态成员。
import java.util.*;
import static java.util.Arrays.*;//导入Arrays这个类中的所有静态成员
public class StaticImportDemo {
public static void main(String[] args) {
int[] arr = {4,3,5};
Arrays.sort(arr);
int index =binarySearch(arr, 1);
System.out.println(Arrays.toString(arr));//当类名重名时,需要制定具体的包名;
//当方法重名时,需要制定具备所属的对象或类。
System.out.println("Index:"+index);
}
}
运行结果: