【笔记-JAVE_WEB】 java泛型

1. 泛型

import java.util.*;

for(object  x : arr)  不能改变其中内容，只能访问元素

不能在<>中写基本类型，只能是基本类型的包装类型

//迭代容遍历

Iterator<String> it = l.iterator();

while(it.hasNext()){

      System.out.println(it.next());

}

class Data<T>

{

T temp;

public void save(T temp)

{

this.temp = temp;

}

public Object get()

{

return temp;

}

}

使用时

Data<String> d = new Data<String>();

d.save("abc");

System.out.println(d.get());

1. 去重、排序
   1. Hash

需要重写方法hashCode和equals

class Data

{

public int i = 0;

//重写方法

public String toString()

{

Integer x = i;

return x.toString();

}

public int hashCode()

{

return i;

}

public boolean equals(Object obj)

{

if(obj == this)

return true;

if(! (obj instanceof Data))

return false;

Data d = (Data)obj;

return i == d.i;

}

}

1. 1. Tree

需要实现Comparable

class Data implements Comparable

{

public int i = 0;

public int compareTo(Object obj)

{//如果是包装类型，可以直接用其中的compareTo函数

Data d = (Data)obj;

return this.i - d.i; //等于返回0，小于返回负数，大于返回正数

}

}

可以自定义排序规则

TreeMap<String,Integer> m = new TreeMap<String,Integer>(new MyComparator());

    

class MyComparator implements Comparator

{

public int compare(Object obj1,Object obj2)

{

String s1 = (String)obj1;

String s2 = (String)obj2;

return s2.compareTo(s1);

}

}

1. Vector

Vector<String> v = new Vector<String>();

v.setSize(10);

v.trimToSize();//使容量和使用长度相等，充分利用空间

排序

vecStu.sort(new Comparator<Student>() {

public int compare(Student o1, Student o2) {

return o1.id - o2.id;}

});

1. 单列集合
   1. ArrayList

封装了一个长度可变的数组，随机访问快

ArrayList<String>  l = new ArrayList<String>();

l.add("abc"); //添加元素

l.size()//获取元素个数

l.get(0)//获取下标为0的元素

l.set(0, "xx");//设置下标为0元素

l.remove(0);//移除第0号元素

List<String>  sub = l.subList(1, 2);//截取部分

l.addAll(1,sub);//添加list中从下标1开始的元素

l.toString();//转换为字符串包含所有元素

1. 1. LinkedList

内部为双向循环链表，删除节点快

特有方法：getFirst(),removeFirst(),addFirst()

1. 1. HashSet

存储的元素不保证有序且不重复

HashSet<Integer>  s = new HashSet<Integer>();

1. 1. TreeSet

存储的元素不重复，且保证有序

1. 双列集合
   1. HashMap
      1. 数据定义

class MyKey

{

public MyKey(int _id) {

id = _id;

}

int  id;

@Override

public int hashCode() {

//hashMap是数组加链表的结构

//id%3表示hashMap是3个位置的数组，每个位置中再根据equals判断是否相等

    //遍历输出时可以看到id顺序是根据%结果放置

return id%3;

}

@Override

public boolean equals(Object obj) {

return id == ((MyKey)obj).id;

}

@Override

public String toString() {

return String.format("%d", id);

}

}

HashMap<MyKey, Double> map= new HashMap<MyKey, Double>();

1. 1. 1. 放入元素

map.put(new MyKey(1), 5.1);

map.put(new MyKey(2), 7.3);

map.put(new MyKey(2), 2.1);//相同则替换

1. 1. 1. 合并

//返回值  参数...

BiFunction<Double, Double, Double> fun = (p1,p2)->{return p1 +p2;};

// BiFunction<Integer, Integer, Integer> fun = new BiFunction<Integer, Integer, Integer>()

// {

//

// @Override

// public Integer apply(Integer t, Integer u) {

// // TODO Auto-generated method stub

// return t + u;

// }

//

// };

map.merge(new MyKey(2), 1.1, fun);//相同则合并

1. 1. 1. 遍历

        //遍历key

        for(MyKey key : map.keySet())

        {

         System.out.println(key);

        }

        

        //遍历value

        for(Double d : map.values())

        {

         System.out.println(d);

        }

        

    

        

        

        //遍历key和value

        for (Map.Entry<MyKey,Double>  o : map.entrySet()) {

System.out.println(o.getKey() + "  " + o.getValue());

}

        

1. 1. 1. 查找

MyKey key = new MyKey(4);

if(map.containsKey(key))//查找

{

       Double b = map.get(key);

       map.put(key, 100.1);//替换

}

1. 1. TreeMap

需要实现Comparable

class MyKey implements Comparable<MyKey>

{

public MyKey(int _id) {

id = _id;

}

int  id;

@Override

public int compareTo(MyKey o) {

return id - o.id;

}

@Override

public String toString() {

return String.format("%d", id);

}

}

键值是按照顺序排列

基本的二叉树都需要满足一个基本性质，即树中的任何节点的值大于它的左子节点，且小于它的右子节点。按照这个基本性质使得树的检索效率大大提高。

TreeMap的实现是红黑树算法的实现，是一颗自平衡的排序二叉树

1. Properties

Properties p = new Properties();

p.setProperty("color", "red");

p.setProperty("size", "12");

System.out.println(p.getProperty("color"));

1. Collections工具类

ArrayList<Double> l = new ArrayList<Double>();     

Collections.reverse(l);//对list进行反转

shuffle(list)//进行随机排序

sort(list)

swap(list,int i, int j)将制定list中i处和j处元素进行交换

addAll(Collection c, T elements)将所有元素添加到制定的collection中

binarySearch(list,object)使用二分法查找有序的list中的某个元素

Object max(Collection col)查找最大元素

Object min(Collection col)

replaceAll(list,oldobj,newobj)用新的obj替换list中所有旧的obj