黑马程序员——Java基础——泛型类、包装类

泛型

集合框架_泛型概述

**泛型：**JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制
好处：
1. 将运行时期出现的问题ClassCastException，转移到了编译时期，方便于程序员解决问题。让运行事情问题减少，安全
2. 避免了强制转换的麻烦

集合框架_泛型的使用

泛型格式：通过<>来定义要操作的引用数据类型

集合框架_泛型类

当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展

public class GenericDemo {
    public static void main(String[] args){
        Tool t = new Tool();
        t.setObject(new Worker());
        Worker w = (Worker)t.getObject();

        Utils<Worker> u = new Utils<Worker>();
        u.setObject(new Worker());
        Worker wo = u.getObject();
    }
}
//泛型前的做法
class Tool{
    private Object obj;
    public void setObject(Object obj){
        this.obj = obj;
    }
    public Object getObject(){
        return obj;
    }
}
//泛型类
class Utils<QQ>{
    private QQ q;
    public void setObject(QQ q){
        this.q = q;
    }
    public QQ getObject(){
        return q;
    }
}
class Worker{

}
class Students{

}

集合框架_泛型方法、静态方法泛型

泛型类定义的泛型，在整个类中有效。
如果没方法使用，那么泛型类的对象明确要操作的具体类型后，所有操作的类型就已经固定
为了让不同方法可以操作不同类型，而且类型不确定,可以将泛型定义在方法上

public class GenericDemo3 {
    public static void main(String[] args){
        Demo d = new Demo();
        d.show("haha");
        d.print("hehe");
    }
}
//泛型类泛型方法混合
class Demo<T>{
    public void show(T t){
        System.out.println("show:" + t);
    }
    public <T> void print(T t){
        System.out.println("print:" + t);
    }
}
/*
静态方法不可以访问类上定义的泛型
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上
*/
public static <W> void method(W w){
    System.out.println("method:" + w);
}
/*
泛型方法
class Demo{
    public <T> void show(T t){
        System.out.println("show:" + t);
    }
    public <T> void print(T t){
        System.out.println("print:" + t);
    }
}
*/
/*
泛型类
class Demo<T>{
    public void show(T t){
        System.out.println("show:" + t);
    }
    public void print(T t){
    System.out.println("print:" + t);
    }
}
*/

集合框架_泛型接口

public class GenericDemo4 {
    public static void main(String[] args){
        Inter_1 i1 = new Inter_1();
        i1.show("haha~");
        Inter_2<Integer> i2 = new Inter_2<Integer>();
        i2.show(100);
    }
}
interface Inter<T>{
    void show(T t);
}
class Inter_1 implements Inter<String>{
    public void show(String t) {
        System.out.println("show:" + t);
    }
}
//在定义类的时候还是不知道使用参数类型是什么
class Inter_2<T> implements Inter<T>{
    public void show(T t) {
        System.out.println("show:" + t);
    }
}

集合框架_泛型限定

上限：? extends E: 可以接收E类型或者E的子类型
下限：？super E：可以接收E类型或者E类型的父类型

public class GenericLimited_1 {
    public static void main(String[] args){
        ArrayList<String> al1 = new ArrayList<String>();
        al1.add("java1");
        al1.add("java2");
        al1.add("java3");
        printColl(al1);
        ArrayList<Integer> al2 = new ArrayList<Integer>();
        al2.add(4);
        al2.add(7); 
        al2.add(1);
        printColl(al2);
    }
    public static void printColl(ArrayList<?> t){
        Iterator<?> it = t.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}
class Personal{
    private String name;
    Personal(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}
class Studentss extends Personal{
    Studentss(String name){
        super(name);
    }
}

public class GenericLimited_2 {
    public static void main(String[] args){
        ArrayList<Personal> alp = new ArrayList<Personal>();
        alp.add(new Personal("java1"));
        alp.add(new Personal("java2"));
        alp.add(new Personal("java3"));
        printColl_2(alp);
        ArrayList<Studentss> als = new ArrayList<Studentss>();
        als.add(new Studentss("ss1"));
        als.add(new Studentss("ss2"));
        als.add(new Studentss("ss3"));
        printColl_2(als);
    }
    public static void printColl_2(ArrayList<? extends Personal> p){
        Iterator<? extends Personal> it = p.iterator();
        while(it.hasNext()){
            System.out.println(it.next().getName());
        }
    }
}
class Personal{
    同上...
}
class Studentss extends Personal{
    同上...
}

public class GenericLimited_3 {
    public static void main(String[] args){
        TreeSet<Stud> tss = new TreeSet<Stud>(new Comp());
        tss.add(new Stud("23635"));
        tss.add(new Stud("234"));
        tss.add(new Stud("45"));
        Iterator<Stud> its = tss.iterator();
        while(its.hasNext()){
            System.out.println(its.next().getName());
        }

        TreeSet<Wor> tsw = new TreeSet<Wor>(new Comp());
        tsw.add(new Wor("w16"));
        tsw.add(new Wor("w7"));
        tsw.add(new Wor("w23"));
        Iterator<Wor> itw = tsw.iterator();
        while(itw.hasNext()){
            System.out.println(itw.next().getName());
        }
    }
}
class Comp implements Comparator<Personal>{
    public int compare(Personal p1, Personal p2) {
        return p2.getName().compareTo(p1.getName());
    }
}
class Pers{
    private String name;
    Pers(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}
class Stud extends Personal{
    Stud(String name){
        super(name);
    }
}
class Wor extends Personal{
    Wor(String name){
        super(name);
    }
}

包装类

基本数据类型包装类_概述

为了方便操作基本数据类型值，将其封装成对象，在对象中定义了属性和行为，丰富了数据的操作
byte- - - - Byte
short- - - -Short
int- - - -Integer
long- - - -Long
float- - - -Float
double- - - -Double
char- - - -Character
boolean- - - -Boolean

基本数据类型包装类_字符串转成基本数值、进制转换

基本类型转换成字符串
基本类型数值 + “”
String类中的静态方法valueOf(基本数值类型);
Integer.value();
字符串转换成基本类型
1. 使用包装类中的静态方法xxx x = Xxxxxxx.parseXxx(“numStr”);例如：int i = Integer.parseInt(“123”);Character没有parse类型
2. 如果数字字符串对象已经被封装在对象中，可以使用intValue();方法
十进制转换成为其他进制
Integer.toBinaryString(数值);
Integer.toOctalString(数值);
Integer.toHexString(数值);
Integer.toString(数值, 进制数);
其他进制转换成为十进制
Integet.parseInt(“110”, 10);

基本数据类型包装类_JDK1.5自动装箱拆箱

JDK1.5之后，如果自动装箱的事一个字节，那么该数据会被共享不会重新开辟空间(-128~127)

Integer a = new Integer(127);
Integer b = new Integer(127);
System.out.println(a == b);
System.out.println(a.equals(b));
Integer c = 127;
Integer d = 127;
System.out.println(c == d);
System.out.println(c.equals(d));

结果为:flase、true、true、true

基本数据类型包装类_练习

对一个字符串中的数值惊醒从小到大的排序

public class Test {
    private static final String SPACE_SEPARATOR = " ";
    public static void main(String[] args){
        String s = "1234 23 252 2351 542435145";
        String f = sortStringNum(s);
        System.out.println(f);
    }
    public static String sortStringNum(String s){
        String[] ss = stringToArray(s);
        int [] num_arr = toIntArray(ss);
        mySortArray(num_arr);
        String temp = arrayToString(num_arr);
        return temp;
    }
    public static String arrayToString(int[] num_arr) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < num_arr.length; i++){
            if(i != num_arr.length - 1)
                sb.append(num_arr[i] + SPACE_SEPARATOR);
            else
                sb.append(num_arr[i]);
        }
        return sb.toString();
    }
    public static void mySortArray(int[] num_arr) {
        Arrays.sort(num_arr);
    }
    public static int[] toIntArray(String[] ss) {
        int[] arr = new int[ss.length];
        for(int i = 0; i < arr.length; i++){
            arr[i] = Integer.parseInt(ss[i]);
        }
        return arr;
    }
    public static String[] stringToArray(String s) {
        String[] ss = s.split(SPACE_SEPARATOR);
        return ss;
    }
}