Java集合2（泛型和Map）

这一片结束，Java集合的基本内容就结束了，下一篇应该是Java的工具类collections和arrays

Java集合可以添加任意类型的对象，在添加了其他类型的对象之后，接下来的操作可能会出现错误，为了解决这种类型安全问题，引入泛型（JDK1.5之后）

package generic;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//测试泛型
public class GenericTest {
public static void main(String[] args) {
List<String> genericList=new ArrayList<String>();
genericList.add("大宝");
genericList.add("小宝");

}

public static void process(List<String>list){
Iterator<String> it=list.iterator();
while(it.hasNext()){
String str=it.next();
if(str!=null){
System.out.println(str.length());
}
}
}
}

泛型类：

当一个类用来操作另外一个类，但是还不确定要操作的是什么类时，就需要泛型类

泛型的两个重要特征：

1、向后兼容：List list=new ArrayList<String>();是正确的

2、不协变性：List <Object> list=new ArrayList<String>();这样是不正确的，就是说在声明一个泛型变量时，前后类型一定要一致，即使是继承关系也是不允许存在的

List list=new ArrayList<String>();

List <String> list=new ArrayList();这两句的差别在于第一个可以添加任何一种类型的元素，而第二个只能添加String类型 元素

 

 

 

 

 

 

Demo类时一个泛型类

package GenericClassTest;
//声明泛型类
public class Demo<T> {
private T t;

public void show(T t){
System.out.println(t);
}

}

 

Person类为一个实体类，这个例子没有任何实际意义，仅仅是为了说明语法

package GenericClassTest;

public class Person {
private String name;
private int age;

public static void main(String[] args) {
//传递对象,给T传入一个String类型的参数，则show方法返回值为String
Demo <String>demo=new Demo<String>();
demo.show("我");
//给T传入一个Integer类型的参数，则show返回值类型为Integer
Demo<Integer> demo2=new Demo<Integer>();
demo2.show(1);
}

public Person(){}


public Person(String name,int age){
this.name=name;
this.age=age;


}


public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

}

 

 

 

泛型通配符 “？”必须跟有限制泛型一起使用，在使用的时候不需要指定泛型就会自动添加泛型

package GenericClassTest;
//演示有限制泛型 extends
public class Demo3<T extends Number> {
public void show(T t){
System.out.println(t);
}
}

 

package GenericClassTest;

public class Demo3Test {
public static void main(String[] args) {

Demo3 demo3=new Demo3();
demo3.show(1);
}

}

 

有限制泛型super：

Demo<? super Integer>demo=new Demo<Integer>();

Demo<? super Integer>demo=new Demo<Number>();

Demo<? super Integer>demo=new Demo<Object>();

这些形式说明，super指定的是类型的下限，=右边指定的类型必须是前边类型的直接或间接父类，方法的参数类型是下限

 

 

Map:

package packageMap;

import java.util.HashMap;
import java.util.Map;

public class MapTest {
public static void main(String[] args) {

Map map=new HashMap();
map.put("aaa", 20);
map.put("BBB", 2131);
map.put("ccc", 39270);

Object obj=map.get("BBB");
System.out.println(obj);


Map<String ,Integer>map2=new HashMap<String,Integer>();
map2.put("DDD", 54345435);
map2.put("EEE", 234532);
int a=map2.get("DDD");
System.out.println(a);
}

}

对map集合的操作

添加 put  删除  remove clear  判断  containsKey   containsValue  isEmpty

获取

1、 get（key）      通过键获得值

2、Set<K> keySet()  所有的key的集合

3、Collection <V> values()所有的Value的集合

4、Set<Map.Entry<K,V>> 所有键值对的集合

5、int  size()map的大小

 

遍历map的三种方式：

package packageMap;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

//遍历map的三种方式
public class MapTest2 {
public static void main(String[] args) {

Map <String ,Integer>map=new HashMap<String,Integer>();

map.put("aaa", 111);
map.put("bbb", 222);
map.put("ccc", 333);
map.put("ddd", 444);
map.put("eee", 555);

//遍历集合方式1：通过map集合提供的keySet方法
Set<String>keySet=map.keySet();
Iterator<String>it=keySet.iterator();
while(it.hasNext()){
String key=it.next();
Integer value=map.get(key);
System.out.println(key+"="+value);
}
//遍历集合方式2：通过map集合的values方法
//虽然可以遍历到所有的value，但是并不知道这些value对应的key
Collection <Integer>values=map.values();
Iterator<Integer>it2=values.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}
//遍历集合方式3：通过集合的entrySet方法

Set<Entry<String,Integer>>entrySet=map.entrySet();
Iterator<Entry<String ,Integer>> it3=entrySet.iterator();
while(it3.hasNext()){
Entry<String,Integer> entry=it3.next();
String key=entry.getKey();
Integer value=entry.getValue();
System.out.println(key+"="+value);

}

}
}

 

模拟HashMap的添加、删除、取出

package exercise;

import java.util.Iterator;
import java.util.LinkedList;

//HashMap 练习
//把前边的MyHashSet改装成一个可以存储三个对象的MaHashMaP
//只需要提供Object[]put(key,v1,v2),Object[]get(key),Object[]remove(key)三个方法
public class MyHashMap {

public static void main(String[] args) {

MyHashMap myHashMap=new MyHashMap();
myHashMap.put("李", 22, 6000);
myHashMap.put("芳", 21, 7000);
myHashMap.put("静", 22, 7000);

Object [] values=myHashMap.get("李");
Object [] removeValues=myHashMap.remove("静");

}



private LinkedList<Entry>[]datas=new LinkedList[10];

public Object[] put(Object key,Object value1,Object value2){
if(key==null){
throw new IllegalArgumentException("键值为空，不合法");
}
//通过哈希值计算在链表中的位置的简单方法
int hashCode=key.hashCode();
int index=hashCode%datas.length;

LinkedList<Entry>linkedList=datas[index];
if(linkedList==null){
linkedList=new LinkedList<Entry>();
datas[index]=linkedList;
}

Iterator<Entry>iterator=linkedList.iterator();
while(iterator.hasNext()){
Entry entry=iterator.next();
if(key.equals(entry.getKey())){
Object oldvalue1=entry.getValue1();
Object oldvalue2=entry.getValue2();
///添加重复的key时，应该进行覆盖
entry.setValue1(value1);
entry.setValue2(value2);
return new Object[]{oldvalue1,oldvalue2};

}
}

Entry entry=new Entry(key,value1,value2);
linkedList.add(entry);
return null;//添加新的key是没有覆盖的情况，返回null即可
}


public Object[] remove(Object key){
if(key==null){
return null;
}
int hashCode=key.hashCode();
int index=hashCode%datas.length;

LinkedList<Entry>linkedList=datas[index];
if(linkedList==null){
return null;
}

Iterator<Entry> iterator=linkedList.iterator();
while(iterator.hasNext()){
Entry obj=iterator.next();
if(key.equals(obj.getKey())){
iterator.remove();
return new Object[]{obj.getValue1(),obj.getValue2()};
}
}
return null;

}

public Object[]get(Object key){


if(key==null){
return null;
}

int hashCode=key.hashCode();
int index=hashCode%datas.length;

LinkedList<Entry> linkedList=datas[index];
if(linkedList==null){
return null;
}

Iterator<Entry> iterator=linkedList.iterator();
while(iterator.hasNext()){
Entry obj=iterator.next();
if(key.equals(obj.getKey())){
return new Object[]{obj.getValue1(),obj.getValue2()};

}
}
return null;

}




class Entry{

private Object key;
private Object value1;
private Object value2;




public Entry() {

}

public Entry(Object key, Object value1, Object value2) {
super();
this.key = key;
this.value1 = value1;
this.value2 = value2;
}
public Object getKey() {
return key;
}
public void setKey(Object key) {
this.key = key;
}
public Object getValue1() {
return value1;
}
public void setValue1(Object value1) {
this.value1 = value1;
}
public Object getValue2() {
return value2;
}
public void setValue2(Object value2) {
this.value2 = value2;
}





}

}

TReeMap：

 

package packageMap;

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

//测试TreeMap
public class TreeMapTest {
public static void main(String[] args) {
TreeMap<String, Integer>treeMap=new TreeMap<String, Integer>();

//测试提那家方法put
treeMap.put("谢霆锋", 22);
treeMap.put("成龙", 50);
treeMap.put("李连杰", 50);


//测试get方法
Integer age1=treeMap.get("成龙");
//System.out.println(age1);

//测试remove方法

// Integer age2=treeMap.remove("谢霆锋");
// System.out.println(age2);


//System.out.println(treeMap);

//自定义排序
//要求按照value降序排序
MyComparator myComparator=new MyComparator(treeMap);

TreeMap<String ,Integer>treeMap2=new TreeMap<String, Integer>(myComparator);
System.out.println(treeMap);
treeMap2.putAll(treeMap);
System.out.println(treeMap2);

}

}
class MyComparator implements Comparator<String>{

private Map<String,Integer>map;
public MyComparator(Map<String,Integer>map){
this.map=map;
}
@Override
public int compare(String key1, String key2) {
Integer value1=map.get(key1);
Integer value2=map.get(key2);
if(value1==null||value2==null){
return 1;

}
if(value1.equals(value2)){
return key1.compareTo(key2);
}
return value2-value1;
}


}

 

HashTable和Properties：

HashTable的内部结构也是哈希表，他是线程安全的，所以对数据的各种操作也是效率很慢，已经被HashMap取代

HashTable有一个子类Properties，既跟集合有关，也可以读取文件

public class PropertiesDebuge {
public static void main(String[] args) throws IOException {

String filePath=PropertiesDebuge.class.getResource("/a.properties").getFile();//src目录下的文件
File file=new File(filePath);
FileReader fileReader=new FileReader(file);


Properties properties=new Properties();
properties.load(fileReader);

String str1=properties.getProperty("你好");
System.out.println(str1);

properties.setProperty("ee", "dddd");
FileWriter fileWriter=new FileWriter(file);
properties.store(fileWriter, "");//这里的a.properties文件不会改变，改变的是在编译时候生成的bin目录下的properties文件
}

}