一、集合工具类 Collections
Collections 是一个操作 Collection(Set、 List )和 Map 等集合的工具类
Collection和Collections的区别?
Collection是用来存储单列数据的集合接口,常用子接口有List和Set
Collections是操作Collection的工具类。
常用方法
排序操作:
- reverse(List): 反转 List 中元素的顺序
- shuffle(List): 对 List 集合元素进行随机排序
- sort(List): 根据元素的自然顺序对指定 List 集合元素按升序排序
- sort(List, Comparator): 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
- swap(List, int, int): 将指定 list 集合中的 i 处元素和 j 处元素进行交换
查找和替换:
- Object max(Collection): 根据元素的自然顺序,返回给定集合中的最大元素
- Object max(Collection, Comparator): 根据 Comparator 指定的顺序,返回给定集合中的最大元素
- Object min(Collection)
- Object min(Collection, Comparator)
- int frequency(Collection, Object): 返回指定集合中指定元素的出现次数
- void copy(List dest,List src):将src中的内容复制到dest中
- boolean replaceAll(List list, Object oldVal, Object newVal): 使用新值替换List 对象的所有旧值
逆序排序
int compareTo(T t)
方法说明
定义:比较此对象与指定对象的顺序
返回:负整数、零或正整数。如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数。
二、list集合排序
第一种是list中的对象实现Comparable接口,如下:
/**
* 根据order对User排序
*/
public class User implements Comparable<User>{
private String name;
private Integer order;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getOrder() {
return order;
}
public void setOrder(Integer order) {
this.order = order;
}
public int compareTo(User arg0) {
return this.getOrder().compareTo(arg0.getOrder());
}
} 测试一下:
public class Test{
public static void main(String[] args) {
User user1 = new User();
user1.setName("a");
user1.setOrder(1);
User user2 = new User();
user2.setName("b");
user2.setOrder(2);
List<User> list = new ArrayList<User>();
//此处add user2再add user1
list.add(user2);
list.add(user1);
Collections.sort(list);
for(User u : list){
System.out.println(u.getName());
}
}
}
复制代码
第二种方法是根据Collections.sort重载方法来实现,例如:
[java] view plain copy
/**
* 根据order对User排序
*/
public class User { //此处无需实现Comparable接口
private String name;
private Integer order;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getOrder() {
return order;
}
public void setOrder(Integer order) {
this.order = order;
}
}
主类中这样写即可(HastSet——>List——>sort进行排序):
public class Test {
public static void main(String[] args) {
User user1 = new User();
user1.setName("a");
user1.setPrice(11);
User user2 = new User();
user2.setName("b");
user2.setPrice(2);
Set<User> Hset = new HashSet<User>();
Hset.add(user2);
Hset.add(user1);
List<User> list = new ArrayList<User>();
list.addAll(Hset);
Collections.sort(list,new Comparator<User>(){
public int compare(User arg0, User arg1) {
return arg0.getPrice().compareTo(arg1.getPrice());
}
});
for(User u : list){
System.out.println(u.getName());
}
}
默认为升序,将。return arg0.getOrder().compareTo(arg1.getOrder()); 改为:
return arg1.getOrder().compareTo(arg0.getOrder());
就成降序的了。
三、泛型
简介
泛型是jdk5引入的类型机制,就是将类型参数化,它是早在1999年就制定的jsr14的实现。
泛型机制将类型转换时的类型检查从运行时提前到了编译时,使用泛型编写的代码比杂乱的使用object并在需要时再强制类型转换的机制具有更好的可读性和安全性。
泛型没有多态、没有数组
泛型的使用
1、主要用在集合中,代码如下:
// 使用泛型
public static void test2(){
List<String> list = new ArrayList<String>();
//list.add(100); 放数据时安全检查,100不是String类型,不能存放
list.add("存数据安全,取数据省心");
String s = list.get(0); //取出来的数据直接就是泛型规定的类型
System.out.println(s);
}
2、自定义泛型接口、泛型类和泛型方法
自定义泛型接口、泛型类和泛型方法与上述Java源码中的List、ArrayList类似。
泛型字母
- 形式类型参数(formal type parameters)即泛型字母
-
命名泛型字母可以随意指定,尽量使用单个的大写字母(有时候多个泛型类型时会加上数字,比如T1,T2)
常见字母(见名知意)- T Type
- K V Key Value
- E Element
- 当类被使用时,会使用具体的实际类型参数(actual type argument)代替
泛型类
- 只能用在成员变量上,只能使用引用类型
public class Student<T> {
private T javase;
//private static T javaee; // 泛型不能使用在静态属性上
public Student() {
}
public Student(T javase) {
this();
this.javase = javase;
}
public T getJavase() {
return javase;
}
public void setJavase(T javase) {
this.javase = javase;
}
}
泛型接口
- 只能用在抽象方法上
public interface Comparator<T1,T2> {
//public static final T1 MAX_VALUE = 100; //接口中泛型字母不能使用在全局常量中
//T1 MAX_VALUE;
public static final int MAX_VALUE = 100;
void compare(T2 t);
T2 compare();
public abstract T1 compare2(T2 t);
}
泛型方法
- 返回值前面加上 <T>
public class Method {
// 泛型方法,在返回类型前面使用泛型字母
public static <T> void test1(T t){
System.out.println(t);
}
// T 只能是list 或者list 的子类
public static <T extends List> void test2(T t){
t.add("aa");
}
// T... 可变参数 ---> T[]
public static <T extends Closeable> void test3(T...a) {
for (T temp : a) {
try {
if (null != temp) {
temp.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws FileNotFoundException {
test1("java 是门好语言");
test3(new FileInputStream("a.txt"));
}
}
泛型的继承
/**
* 泛型继承
*
* 保留父类泛型 ----》泛型子类
* 不保留父类泛型 -----》子类按需实现
*
* 子类重写父类的方法,泛型类型随父类而定 子类使用父类的属性,该属性类型随父类定义的泛型
*
* @author Administrator
*
* @param <T1>
* @param <T2>
*/
public abstract class Father<T1, T2> {
T1 age;
public abstract void test(T2 name);
}
// 保留父类泛型 ----》泛型子类
// 1)全部保留
class C1<T1, T2> extends Father<T1, T2> {
@Override
public void test(T2 name) {
}
}
// 2) 部分保留
class C2<T1> extends Father<T1, Integer> {
@Override
public void test(Integer name) {
}
}
// 不保留父类泛型 -----》子类按需实现
// 1)具体类型
class C3 extends Father<String, Integer> {
@Override
public void test(Integer name) {
}
}
// 2)没有具体类型
// 泛型擦除:实现或继承父类的子类,没有指定类型,类似于Object
class C4 extends Father {
@Override
public void test(Object name) {
}
}
extends/super
上限(extends)
指定的类必须是继承某个类,或者实现了某个接口(不是implements),即<=
- ? extends List
下限(super)
即父类或本身
- ? super List
import java.util.ArrayList;
import java.util.List;
泛型嵌套
从外向里取
public static void main(String[] args) {
Student2<String> student = new Student2<String>();
student.setScore("优秀");
System.out.println(student.getScore());
//泛型嵌套
School<Student2<String>> school = new School<Student2<String>>();
school.setStu(student);
String s = school.getStu().getScore(); //从外向里取
System.out.println(s);
// hashmap 使用了泛型的嵌套
Map<String, String> map = new HashMap<String,String>();
map.put("a", "张三");
map.put("b", "李四");
Set<Entry<String, String>> set = map.entrySet();
for (Entry<String, String> entry : set) {
System.out.println(entry.getKey()+":"+entry.getValue());
}
}