编写高质量代码:改善Java程序的151个建议-学习笔记

java中通用的方法和准则

1.不要让常量和变量中出现易混淆的字母

比如: long i = 1l;

别人很难一下子看清楚是11还是1l，所以应该这样写1L。

命名规范:

1.包名全部小写

2.类名首字母大写

3.方法名称，首字母小写，后面单词首字母大写

4.常量要用大写，并且用下划线隔开

5.变量要用小写

2.莫让常量蜕变成变量

    interface Const {
        public static final int RANDOM_NUM = new Random().nextInt(10);
    }

        for (int j = 0; j < 5; j++) {
            Log.i("clp", "num =" + Const.RANDOM_NUM);
        }

上面的代码，每次运行值都会不一样。

RE:只有在值固定的时候，才考虑用final。否则轻易不要用。 static有时候在临时保存数据的时候会用到。

3.三元操作符的类型务必一致

        int i = 80;
        String s1 = String.valueOf(i < 100 ? 90 : 100);
        String s2 = String.valueOf(i < 100 ? 90 : 100.0);
        Log.i("clp", "s1=" + s1);
        Log.i("clp", "s2=" + s2);

I/clp: s1=90
I/clp: s2=90.0

规则:

1.如果2个类型不能相互转换，就返回Object类型

2.如果是明确类型的表达式(比如变量)，则int类型转为long，long类型转为float

…还有其他规则

4.避免带有边长参数的方法重载

    public int getCount(int type, int i, int j) {
        return i + j;
    }

    public int getCount(int type, int... value) {
        int count = 0;
        for (int i : value) {
            count *= i;
        }
        return count;
    }

        Log.i("clp", "count=" + getCount(1, 3, 4));

上面的代码，很容易搞混，可能不分析具体原因，不知道会调用那个。

RE:其实会调用int参数的那个，因为编译器从最简单的开始。

I/clp: count=7

5.不要让null或者空值影响到边长方法

    public void methodA(String name, Integer... value) {

    }

    public void methodA(String name, String... value) {

    }

        methodA("a", 1, 2);
        methodA("b", "e", "e");
        methodA("c");//编译器报错
        methodA("c", null);//编译器报错

上面解决的办法是传入空的String。

RE:我感觉最好的办法是，避免这种写法，遇到这种情况，不要去重载。

基本类型

27.谨慎包装类型的大小比较

Integer i = new Integer(2);
Integer j = new Integer(2);
//比较封装对象的大小，只能使用i.compareTo(j)。
//i==j,i>j,j<j都返回false。  i==j是返回对象的引用地址。i>j,j<j是值的比较。

28.优先使用整形池

        int input = 127;//128 555
        Integer ii = new Integer(input);
        Integer jj = new Integer(input);
        Log.i("clp", "new 产生的对象:" + (ii == jj));//都为false
        ii = input;
        jj = input;
        Log.i("clp", "基本类型产生的对象" + (ii == jj));//127为true，128 555为false
        ii = Integer.valueOf(input);
        jj = Integer.valueOf(input);
        Log.i("clp", "valueOf 产生的对象" + (ii == jj));//127为true，128 555为false

1.new产生的对象比较，肯定为false

2.自动装箱和Integer.valueOf一样(装箱时通过valueOf实现)

3.valueOf的实现方式，在-128和127之间，使用的是缓冲。超过的话，直接new

    public static Integer valueOf(int i) {
        final int offset = 128;
        if (i > -128 && i < 127) {
            return IntegerCache.cache[i + offset];
        }
        return new Integer(i);
    }

29.优先使用基本类型

        int i = 14;
        f(i);
        f(Integer.valueOf(i));

    public static void f(long i) {
        Log.i("clp", "基本类型的方法被调用");
    }

    public static void f(Long i) {
        Log.i("clp", "包装的方法被调用");
    }

输出结果:

Log.i(“clp”, “基本类型的方法被调用”);

解析:1.自动装箱只有在赋值时才有关系，重载可以编译通过

2.f(i)不会报错，因为编辑器会自动把i加宽，变为long

3.f(Integer.valueOf(i))不会报错:基本类型，可以先加宽在包装。但是不能直接包装。所以1.先转变为Integer对象，然后调用方法的时候发现没有，自动转换为int基本类型 3.发现没有，自动加宽变为long

4.如果把f(long i)方法给注释掉，代码是编译不通过的

30.不要随便设置随机种子

Random random = new Random(1000);
        for (int i = 0; i < 4; i++) {
            CldLog.i("clp", "第" + i + "次的随机数为:" + random.nextInt());
        }

RE:按照上面的代码写，每次运行都会得到想通的随机数。通过Random random = new Random()，则不能固定范围

04-15 11:35:44.565 15244-15244/cld.navi.mainframe I/clp: 第0次的随机数为:-1244746321 @initControls:CldModeA.java(72)

04-15 11:35:44.565 15244-15244/cld.navi.mainframe I/clp: 第1次的随机数为:1060493871 @initControls:CldModeA.java(72)

04-15 11:35:44.565 15244-15244/cld.navi.mainframe I/clp: 第2次的随机数为:-1826063944 @initControls:CldModeA.java(72)

04-15 11:35:44.565 15244-15244/cld.navi.mainframe I/clp: 第3次的随机数为:1976922248 @initControls:CldModeA.java(72)

正确写法如下:

        Random random = new Random();
        for (int i = 0; i < 4; i++) {
            CldLog.i("clp", "第" + i + "次的随机数为:" + random.nextInt(20));
        }

类、对象及方法

31.接口中不要存在实现代码

RE:这个都知道

32.静态变量一定要先声明后赋值

    static {
        i = 100;
    }
    public static int i = 1;
    //输出结果，i等于1
    public static int i = 1;
    static {
        i = 100;
    }
    //输出结果，i等于100

1.静态变量是类加载的时候分配到存储区的

2.静态变量在类初始化的时候首先被加载，分配地址空间，还没赋值

3.按照静态类和静态块的先后顺序赋值，所以谁的位置在后面，谁有最终的决定权

33.不要复写静态方法

public class Base {

    public static void doBaseStatic() {
        Log.i("clp", "doBaseStatic");
    }

    public void doBase() {
        Log.i("clp", "doBase No Static");
    }

}

public class Sub extends Base {

    public static void doBaseStatic() {
        Log.i("clp", "do Sub Static");
    }

    public void doBase() {
        Log.i("clp", "do Sub No Static");
    }

}

        Base mBase = new Sub();
        mBase.doBase();//do Sub No Static
        Base.doBaseStatic();//doBaseStatic
        mBase.doBaseStatic();//doBaseStatic
        //Android Studio用上面的写法会提示
        Sub.doBaseStatic();//do Sub Static

1.mBase.doBaseStatic()实际上调用的是父类的方法。因为静态方法不依赖实例对象，是通过类名访问的

34.构造函数尽量简化

public abstract class Server {

    public static int DEFAULT_PORT = 4000;

    public Server() {
        Log.i("clp", "Server");
        int port = getPort();
        Log.i("clp", "port=" + port);
//        Log.i();
    }

    protected abstract int getPort();

}

public class ServerIml extends Server {

    public int port = 100;

    public ServerIml(int port) {
        Log.i("clp", "ServerIml");
        this.port = port;
    }

    @Override
    protected int getPort() {
//        return port;//值为0
        return DEFAULT_PORT;//返回值4000
    }
}

ServerIml serverIml = new ServerIml(80);

这个跟构造方法的执行顺序有关。

04-15 14:35:54.027 7381-7381/com.example.demo I/clp: Server

04-15 14:35:54.027 7381-7381/com.example.demo I/clp: port=4000

04-15 14:35:54.027 7381-7381/com.example.demo I/clp: ServerIml

执行顺序如下:

1.子类的构造函数接收int类型的参数(没有赋值)

2.父类初始化常量，也就是DEFAULT_PORT，并赋值为4000

3.执行父类无参的构造方法

4.调用int port = getPort();获取端口号，调用子类端口号的实现方法。此时DEFAULT_PORT已经有值，但是port子类的

构造函数还没有执行，所以没有赋值，返回0

5.父类初始化完毕，开始初始化子类

6.子类被赋值为100

7.执行子类的构造函数，重新赋值为80

35.避免在构造函数中初始化其他类

public class Son extends Father {

    public void doSomeThing() {
        Log.i("clp", "doSomeThing");
    }

}

public class Father {

    Father() {
        new Other();
    }

}

public class Other {

    Other() {
        new Son();
    }

}

Son son = new Son();
        son.doSomeThing();

上面的代码，直接回导致程序死掉。陷入死循环。

36.使用构造代码块精炼程序

代码块:

1.使用static{}的静态代码块。类创建的时候加载

2.方法后面{}的普通代码块，必须通过调用方法名称使用

3.synchronize修饰的同步代码块

4.构造代码块，在类中没有任何修饰，直接使用{}

public class CldGouzaoUtil {
    {
        Log.i("clp", "构造代码块");
    }

    public CldGouzaoUtil() {
        Log.i("clp", "构造方法");
    }
}

04-15 14:59:55.597 22529-22529/com.example.demo I/clp: 构造代码块

04-15 14:59:55.597 22529-22529/com.example.demo I/clp: 构造方法

构造代码块，不同于static代码块，它是依赖于构造方法执行。所以用途主要为

1.初始化实例变量

2.初始化实例环境

RE:2个都是在构造方法执行前执行一些初始化、检测的操作。

37.构造代码块会想你所想

public class CldGouzaoUtil {

    protected static int numOfNew = 0;

    {
        numOfNew++;
    }

    public CldGouzaoUtil() {

    }

    public CldGouzaoUtil(String mDes) {
        this();
    }

    public static int getNumOfNew() {
        return numOfNew;
    }

}

        new CldGouzaoUtil();
        new CldGouzaoUtil("haha");
        new CldGouzaoUtil("haha");
        Log.i("clp", "初始化的次数为:" + CldGouzaoUtil.getNumOfNew());

04-15 15:31:37.737 19985-19985/com.example.demo I/clp: 初始化的次数为:3

new CldGouzaoUtil(“haha”)这种构造函数调用this的，构造代码块也只会执行一次。而且只要不杀死程序，次数会一直保留。

38.使用静态内部类提高封装性

//使用静态内部类加强类的封装性和提高代码的可读性
public class CldInnerStatic {
    //提高封装性-比如这个代表home是外部类的子行为
    //提高代码的可读性
    //形似内部，神似外部---可以脱离外部存在
    String name;
    public Home home;

    private static int outer = 100;

    public CldInnerStatic(String name) {
        this.name = name;
    }

    public void setHome(Home home) {
        this.home = home;
    }

    //不持有外部类的引用
    //静态内部类不依赖外部类
    public static class Home {//静态内部类

        public String addr;//地址

        public int tel;//家庭电话

        public Home(String addr, int tel) {
            this.addr = addr;
            this.tel = tel;

//            name = "哈哈";//报错-不能访问外部类的变量
            outer = 80;//静态内部类可以访问外部类static的变量
        }
    }

    public class Company {

//        public static int comAddr = "";//报错-普通内部类不能声明static的方法和变量

        //报错
//        public static void setComName() {//普通内部类不能声明static的方法和变量
//
//        }
    }

CldInnerStatic innerStatic = new CldInnerStatic("张三");
innerStatic.setHome(new CldInnerStatic.Home("上海", 02166666666));

39.使用匿名内部类的构造函数

        List<String> mList = new ArrayList<>();
        List<String> mList2 = new ArrayList<>() {
        };

        List<String> mList3 = new ArrayList<>() {
            {//代码块
            }
        };

第二种和第三种都是相当于匿名内部类List mlist2 = new Sub();

40.匿名类的构造函数很特殊

public class CldCalculator {

    {//在这里，计算出来的值就为0，在使用的地方就是正确的
        setOperator();
        Log.i("clp", "setOperator");
    }

    private int i, j, result;

    public CldCalculator() {

    }

    public CldCalculator(int i, int j) {
        Log.i("clp", "CldCalculator");
        this.i = i;
        this.j = j;
    }

    protected void setOperator() {
        result = i + j;
    }

    public int getResult() {
        return result;
    }

}

public class SubCal extends CldCalculator {

    {//在这里，计算出来的值就为0，在使用的地方就是正确的
        setOperator();
        Log.i("clp", "setOperator");
    }

    public SubCal(int i, int j) {

    }

}

        CldCalculator calculator = new CldCalculator(1, 2) {
//            {
//                setOperator();//这里使用，值是正确的
//                Log.i("clp", "setOperator");
//            }
        };
        Log.i("clp", "result=" + calculator.getResult());

        CldCalculator calculator1 = new SubCal(1, 2);
        Log.i("clp", "calculator1=" + calculator.getResult());//结果为0

两个结果不一样，因为匿名内部类的特殊处理机制。一般的类都是默认调用父类的无参构造。但是匿名类没有名字，直接由

构造代码块代替，直接调用了父类的同参构造方法。然后再调用自己的构造代码块。

41.让多继承成为现实

使用内部类，巧妙的实现多继承

public interface Father {
    int Strong();//强壮指数
}

public interface Mother {
    int kind();//温柔指数
}

public class FatherIml implements Father {
    @Override
    public int Strong() {
        return 8;
    }
}

public class MotherIml implements Mother {
    @Override
    public int kind() {
        return 8;
    }
}

public class Son extends FatherIml implements Mother {
    @Override
    public int Strong() {
        return super.Strong() + 2;//比付清还要强壮
    }

    @Override
    public int kind() {
        return new MotherIml() {
            @Override
            public int kind() {
                return super.kind() - 2;//温柔比母亲少了2个点
            }
        }.kind();
    }
}

        Son son = new Son();
        Log.i("clp", "strong =" + son.Strong() + ";kind=" + son.kind());
        //结果:04-15 17:32:13.267 14610-14610/? I/clp: strong =10;kind=6

42.让工具类不可实例化

工具类的正确构建方式:1.不能实例化 2.不能继承

public final class CldUtil {

    private CldUtil() {
        throw new Error("不要实例化我");
    }
}

43.避免对象的浅拷贝

public class Person implements Cloneable {
    //名称
    private String name;
    //父亲
    private Person father;

    public Person(String name) {
        this.name = name;
    }

    public Person(String name, Person father) {
        this.name = name;
        this.father = father;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setFather(Person father) {
        this.father = father;
    }

    public String getName() {
        return name;
    }

    public Person getFather() {
        return father;
    }

    @Override
    public Person clone() {//对象的拷贝
        Person p = null;
        try {
            p = (Person) super.clone();
            p.setFather(new Person(p.getFather().getName()));//如果没有这句话，就是浅拷贝，加了这句话，就是深拷贝
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return p;
    }
}

        Person father = new Person("父亲");
        Person p1 = new Person("大儿子", father);
        Person p2 = p1.clone();
        p2.setName("小儿子");
//        p2.setFather(new Person("干爹"));
        p2.getFather().setName("干爹");
        Log.i("clp", "fist name=" + p1.getName() + ";father =" + p1.getFather().getName());
        Log.i("clp", "sec name=" + p2.getName() + ";father =" + p2.getFather().getName());

使用浅拷贝

04-15 17:55:30.827 2810-2810/com.example.demo I/clp: fist name=大儿子;father =干爹

04-15 17:55:30.827 2810-2810/com.example.demo I/clp: sec name=小儿子;father =干爹

使用p2.setFather(new Person(“干爹”));或者深拷贝

04-15 17:58:27.197 2810-2810/com.example.demo I/clp: fist name=大儿子;father =父亲

04-15 17:58:27.197 2810-2810/com.example.demo I/clp: sec name=小儿子;father =干爹

44.推荐使用序列化实现对象的拷贝

public class Person implements Serializable {
    private static final long serialVersionUID = 201704161112L;
    //名称
    public String name;
    //父亲
    public Person person;

    public Person(String name) {
        this.name = name;
    }

    public Person(String name, Person person) {
        this.name = name;
        this.person = person;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
}

    //使用字节流实现对象的拷贝
    public static <T extends Serializable> T clone(T obj) {
        //final和static的序列化问题会被引入到对象的拷贝中???
        //transient变量也会影响到拷贝的结果???
        T cloneObj = null;
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(obj);//如果不实现序列化，则会抛出序列化异常
            objectOutputStream.close();
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            cloneObj = (T) objectInputStream.readObject();
            objectInputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cloneObj;
    }

01-04 19:27:44.620 17104-17104/old.pkg.com.myapplicati I/clp: 名称:小儿子;父亲为:父亲

01-04 19:27:44.620 17104-17104/old.pkg.com.myapplicati I/clp: 名称:大儿子;父亲为:干爹

45.复写equals方法时不要识别不出自己

public class Person {
    //名称
    public String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Person) {
            Person person = (Person) obj;
            //equalsIgnoreCase为忽略大小写
            return name.equalsIgnoreCase(person.getName());
//            return name.equalsIgnoreCase(person.getName().trim());
//            01-04 19:41:01.360 30991-30991/old.pkg.com.myapplicati I/clp: p1 is equals =false
//
//            return name.equalsIgnoreCase(person.getName());
//            01-04 19:41:48.420 32459-32459/old.pkg.com.myapplicati I/clp: p1 is equals =true
        }
        return super.equals(obj);
    }
}

        Person p1 = new Person("张三  ");
        Log.i("clp", "p1 is equals =" + p1.equals(p1));

使用:

return name.equalsIgnoreCase(person.getName().trim());

01-04 19:41:01.360 30991-30991/old.pkg.com.myapplicati I/clp: p1 is equals =false

return name.equalsIgnoreCase(person.getName());

01-04 19:41:48.420 32459-32459/old.pkg.com.myapplicati I/clp: p1 is equals =true

46.equals应该考虑null值情景

接上面的例子，如果按照下面的方式判断，就会报错

        Person p1 = new Person("张三  ");
        Person p2 = new Person(null);
        Log.i("clp", "p1 p2 is equals =" + p2.equals(p1));

所以，应该按照下面的写:

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Person) {
            Person person = (Person) obj;
            if (person.getName() == null || name == null) {
                return false;
            }
            //equalsIgnoreCase为忽略大小写
            return name.equalsIgnoreCase(person.getName());
//            return name.equalsIgnoreCase(person.getName().trim());
//            01-04 19:41:01.360 30991-30991/old.pkg.com.myapplicati I/clp: p1 is equals =false
//
//            return name.equalsIgnoreCase(person.getName());
//            01-04 19:41:48.420 32459-32459/old.pkg.com.myapplicati I/clp: p1 is equals =true
        }
        return super.equals(obj);
    }

47.在equals中使用getClass进行类型判断

接上面例子，如果有一个子类，代码如下:

public class ManPerson extends Person {

    public int id;

    public ManPerson(String name, int id) {
        this.name = name;
        this.id = id;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof ManPerson) {
            ManPerson person = (ManPerson) obj;
            return super.equals(obj) && person.id == id;
        }
        return super.equals(obj);
    }
}

然后进行判断:

        Person p1 = new Person("张三");
        ManPerson manPerson = new ManPerson("张三", 100);
        Log.i("clp", "p1 manPerson is equals =" + p1.equals(manPerson));

结果是true。

这是因为p1为父类，所以使用了父类的equals方法进行判断。关键就是equals方法中使用了instanceof。故修改如下:

    @Override
    public boolean equals(Object obj) {
        if (obj.getClass() != null && obj.getClass() == this.getClass()) {
            Person person = (Person) obj;
            if (person.getName() == null || name == null) {
                return false;
            }
            //equalsIgnoreCase为忽略大小写
            return name.equalsIgnoreCase(person.getName());
//            return name.equalsIgnoreCase(person.getName().trim());
//            01-04 19:41:01.360 30991-30991/old.pkg.com.myapplicati I/clp: p1 is equals =false
//
//            return name.equalsIgnoreCase(person.getName());
//            01-04 19:41:48.420 32459-32459/old.pkg.com.myapplicati I/clp: p1 is equals =true
        }
        return super.equals(obj);
    }

48.覆写equals方法必须覆写hashCode方法

        Map<Person, Object> map = new HashMap<Person, Object>() {
            {
                put(new Person("张三"), new Object());
            }
        };
        Log.i("clp", "map has key=" + map.containsKey(new Person("张三")));

上面方法，如果不覆写hashCode，会返回false。

因为map是根据hashCode值决定数组的下标(HashMap底层是通过数组保存的)。如果不覆写，每一个对象都有一个hasCode，自然会找不到

所以Person类中添加如下方法:

    @Override
    public int hashCode() {
        return name.hashCode();
    }

49.推荐覆写toString()

原因是本身，此此方法返回的是对象引用的地址值。

01-04 21:29:51.320 27893-27893/old.pkg.com.myapplicati I/clp: person [email protected]

        Person person = new Person("张三");
        Log.i("clp", "person =" + person.toString());

01-04 21:29:12.490 26591-26591/old.pkg.com.myapplicati I/clp: person =name =张三

50.使用package-info类为包服务

作用:

1.声明友好类和包内访问常量

2.为在包上标注注解提供便利

3.提供包的整体注释说明

51.不要主动进行垃圾回收

因为System.gc会停止所有的相应，去进行检测内存中是否有可回收的对象。可能会比较耗时，10S或者20S也说不准。

字符串

52.推荐使用String直接量赋值

        String s1 = "张三";
        String s2 = " 张三 ";
        String s3 = new String("张三");
        String s4 = s3.intern();
        Log.i("clp", " s1 s2 is equals=" + (s1 == s2));
        Log.i("clp", " s1 s3 is equals=" + (s1 == s3));
        Log.i("clp", " s1 s4 is equals=" + (s1 == s4));

01-04 21:51:49.220 19875-19875/old.pkg.com.myapplicati I/clp: s1 s2 is equals=false

01-04 21:51:49.220 19875-19875/old.pkg.com.myapplicati I/clp: s1 s3 is equals=false

01-04 21:51:49.220 19875-19875/old.pkg.com.myapplicati I/clp: s1 s4 is equals=true

Java为了避免产生大量的对象，内部有一个字符串池。创建字符串时，会先判断池子中是否有这个字符串，有就直接返回，

如果没有，就创建一个，丢到池子当中，并返回。

使用new 创建，肯定是新建了一个对象。

intern方法会检查当前的对象，在池子中是否有字面值相等的引用对象，如果有就返回池子中的对象，没有就放置到池子中，并返回。

会不会有线程安全问题?

String是一个不可变对象。

1.不可能有子类

2.String中提供的方法中的返回值，都会新建一个对象，不会对原对象进行修改。

要不要考虑垃圾回收?

字符串池，是保存子JVM的常量池当中，不会进行垃圾回收。

53.注意参数中传递的参数要求

    //删除字符串
    public static String remove(String orgin, String sub) {
        return orgin.replaceAll(sub, "");
    }

        Log.i("clp", "result =" + CldStringUtil.remove("好是好", "好"));
        Log.i("clp", "result =" + CldStringUtil.remove("$是$", "$"));

结果:

01-04 22:08:33.220 6359-6359/old.pkg.com.myapplicati I/clp: result =是

replaceAll要求第一个参数是正则表达式。$这个符号在正则表达式中是字符串的结束位置。

修改如下:

    //删除字符串
    public static String remove(String orgin, String sub) {
        while (orgin.contains(sub)) {
            orgin = orgin.replace(sub, "");
        }
        return orgin;
    }

54.正确使用String、StringBuffer、StringBuilder

1.String一旦创建，不可变

2.StringBuffer是线程安全的，StringBuilder是线程不安全的。

所以StringBuffer的性能要比StringBuilder低。

3.性能方法，因为String每次都会新建，所以会远慢于StringBuffer和StringBuilder

55.注意字符串的位置

        String s1 = 1 + 2 + "abc";
        String s2 = "abc" + 1 + 2;
        Log.i("clp", "s1=" + s1);
        Log.i("clp", "s2=" + s2);

01-05 06:40:30.540 28819-28819/old.pkg.com.myapplicati I/clp: s1=3abc

01-05 06:40:30.540 28819-28819/old.pkg.com.myapplicati I/clp: s2=abc12

1.从左到右依次拼接

2.只要遇到String，则所有数据都转换为String类进行拼接

3.如果是原始数据，则直接进行拼接，如果是对象，则调用toString()

4.在+表达式中，String具有最高的优先级

56.自由选择字符串拼接方法

    String s = "";
    long time = System.currentTimeMillis();
    for (int i = 0; i < 5000; i++) {
        s += "a";
    }
    long timeend = System.currentTimeMillis() - time;
    Log.i("clp", "time1 =" + timeend);

    String a = "";
    long time2 = System.currentTimeMillis();
    for (int i = 0; i < 5000; i++) {
        s = s.concat("a");
    }
    long timeend2 = System.currentTimeMillis() - time2;
    Log.i("clp", "time1 =" + timeend2);

    StringBuilder b = new StringBuilder();
    long time3 = System.currentTimeMillis();
    for (int i = 0; i < 5000; i++) {
        b.append("a");
    }
    long timeend3 = System.currentTimeMillis() - time3;
    Log.i("clp", "time1 =" + timeend3);

    StringBuffer c = new StringBuffer();
    long time4 = System.currentTimeMillis();
    for (int i = 0; i < 5000; i++) {
        c.append("a");
    }
    long timeend4 = System.currentTimeMillis() - time4;
    Log.i("clp", "time1 =" + timeend4);

01-05 06:53:02.410 3080-3080/old.pkg.com.myapplicati I/clp: time1 =1160

01-05 06:53:04.070 3080-3080/old.pkg.com.myapplicati I/clp: time1 =1668

01-05 06:53:04.080 3080-3080/old.pkg.com.myapplicati I/clp: time1 =5

01-05 06:53:04.090 3080-3080/old.pkg.com.myapplicati I/clp: time1 =8

书上说concat执行时间比直接添加少一倍。但是在我手机上测试为啥还要高???

57.推荐在复杂字符串操作中使用正则表达式

//使用正则表达式计算单词的数量
    public static int getCount(String word) {
        //正在表达式
        Pattern pattern = Pattern.compile("\\b\\w+\\b");
        Matcher matcher = pattern.matcher(word);
        int count = 0;
        while (matcher.find()) {
            count++;
        }
        return count;
    }

        String s = "How are you !Good!";
        Log.i("clp", "count=" + CldStringUtil.getCount(s));

01-05 07:10:17.220 8910-8910/old.pkg.com.myapplicati I/clp: count=4

58.强烈建议使用UTF编码

文件格式为UTF-8

        try {
            String s = "张三";
            byte[] b = s.getBytes("GBK");
            Log.i("clp", "string is =" + new String(b));
            Log.i("clp", "string is =" + new String(b, "GBK"));
        } catch (Exception e) {

        }

输出结果:

01-05 07:20:10.370 11249-11249/old.pkg.com.myapplicati I/clp: string is =????

01-05 07:20:10.370 11249-11249/old.pkg.com.myapplicati I/clp: string is =张三

59.对字符串排序持一种宽容的态度

1.使用Arrays.sort肯定不行，它是根据UNICODE代码表来排序的。

2.使用Collator，但是只能包含常用的7000多个汉字。

        String[] sortName = {"张三", "李四", "王五"};
        Comparator c = Collator.getInstance(Locale.CHINA);
        Arrays.sort(sortName, c);
        for (String str : sortName) {
            Log.i("clp", "name =" + str);
        }

原因:java使用UNICODE编码。

GB2312->GB18030->UNICODE

数组和集合

60.性能考虑，数组是首选

    //基本类型是在栈内操作的。而对象是在堆内操作的。
    //栈的特点是:速度快、容量小   堆的特点是:速度慢，容量大。
    public static int getCountArray(int[] list) {
        int sum = 0;
        long time = System.currentTimeMillis();
        for (int i = 0; i < list.length; i++) {
            sum += list[i];
        }
        long timeend = System.currentTimeMillis() - time;
        Log.i("clp", "array time is =" + timeend);
        return sum;
    }

    public static int getCountList(List<Integer> list) {
        int sum = 0;
        long time = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            sum += list.get(i);//做了一次拆箱操作。Integer通过intValue方法自动转换为了int基本类型
        }
        long timeend = System.currentTimeMillis() - time;
        Log.i("clp", "data time is =" + timeend);
        return sum;
    }

        int[] data = new int[100000];
        for (int i = 0; i < data.length; i++) {
            data[i] = 2;
        }
        CldArrayUtil.getCountArray(data);
        List<Integer> list = new ArrayList<Integer>();
        for (int j = 0; j < 100000; j++) {
            list.add(2);
        }
        CldArrayUtil.getCountList(list);

01-05 08:13:19.740 21326-21326/old.pkg.com.myapplicati I/clp: array time is =4

01-05 08:13:19.880 21326-21326/old.pkg.com.myapplicati I/clp: data time is =35

数组的效率是集合的10倍。这个说法是对的。

61.若有必要，使用变长数组

    public static int[] expandArray(int[] data, int length) {//指定新的数组长度
        if (length < 0) {
            length = 0;
        }
        return Arrays.copyOf(data, length);
    }

        int[] data = new int[20];
        for (int i = 0; i < data.length; i++) {
            data[i] = 2;
        }
        data = CldArrayUtil.expandArray(data, 50);
        Log.i("clp", "length =" + data.length);
        Log.i("clp", "data[2]=" + data[2]);

01-05 08:26:57.310 23679-23679/old.pkg.com.myapplicati I/clp: length =50

01-05 08:26:57.310 23679-23679/old.pkg.com.myapplicati I/clp: data[2]=2

62.警惕数组的浅拷贝

Arrays.copyOf为数组的浅拷贝，如果是基本类型，直接拷贝值。如果是对象，拷贝的是引用地址。

所以如果改变拷贝后的对象的值，拷贝前的值也会发生变化。

解决方式:重新生成对象。

63.在明确的场景下，为集合指定初始容量

1.例如ArrayList，如果不指定，初始容量为10.每次如果长度不够，就自动扩容到1.5倍。

所以，如果要指定一个长度为50的List，最好直接指定容量

        List<String> mlist = new ArrayList<>(50);
        for (int i = 0; i < 60; i++) {//列表长度为50，添加60个元素
            mlist.add("2");
        }
        Log.i("clp", "list size =" + mlist.size());

01-05 19:23:08.320 4367-4367/old.pkg.com.myapplicati I/clp: list size =60

Vector、HashMap、Stack类似。

64.多种最值算法，适时选择

        int[] data = new int[100000];
        for (int i = 0; i < data.length; i++) {
            data[i] = new Random().nextInt(10000);
        }
        //使用数组排序
        int max = data[0];
        long time = System.currentTimeMillis();
        for (int i : data) {
            max = max > data[i] ? max : data[i];
        }
        long timeEnd = System.currentTimeMillis() - time;
        Log.i("clp", "timeEnd=" + timeEnd);
        Log.i("clp", "max data = " + max);

01-05 19:35:47.690 8007-8007/old.pkg.com.myapplicati I/clp: timeEnd=6

01-05 19:35:47.690 8007-8007/old.pkg.com.myapplicati I/clp: max data = 9999

        int[] data = new int[100000];
        for (int i = 0; i < data.length; i++) {
            data[i] = new Random().nextInt(10000);
        }
        //使用Arrays排序
        int max = data[0];
        long time = System.currentTimeMillis();
        Arrays.sort(data.clone());
        long timeEnd = System.currentTimeMillis() - time;
        Log.i("clp", "timeEnd=" + timeEnd);
        Log.i("clp", "max data = " + data[data.length - 1]);

01-05 19:37:36.810 9440-9440/old.pkg.com.myapplicati I/clp: timeEnd=172

01-05 19:37:36.810 9440-9440/old.pkg.com.myapplicati I/clp: max data = 9281

排序10万个数据，才有细微的差别。所以，小数据性能影响不大。用Arrays.sort排序代码可读性高一点。

求第二大元素,正常通过数据循环查找可以搞定，下面使用TreeSet实现(过滤掉相同数据).

        long time = System.currentTimeMillis();
        List<Integer> mList = Arrays.asList(data);
        TreeSet<Integer> ts = new TreeSet<Integer>(mList);
        int max = ts.lower(ts.last());
        long timeEnd = System.currentTimeMillis() - time;
        Log.i("clp", "timeEnd=" + timeEnd);
        Log.i("clp", "sec max data = " + max);

01-05 19:42:18.750 10551-10551/old.pkg.com.myapplicati I/clp: timeEnd=1092

01-05 19:42:18.750 10551-10551/old.pkg.com.myapplicati I/clp: sec max data = 9998

65.避开基本类型数组转换列表陷进

        int[] data = new int[100000];
        for (int i = 0; i < data.length; i++) {
            data[i] = new Random().nextInt(10000);
        }
        List mList = Arrays.asList(data);
        Log.i("clp", "list size =" + mList.size());

01-05 19:50:27.710 13585-13585/old.pkg.com.myapplicati I/clp: list size =1

asList需要输入一个泛型化的边长参数，基本类型是不能泛型化的，但是数组可以。所以上面就把数组泛型化为只有一个数组的。

mList.get(0)数据如下:

其他7个基本类型也有这个问题，所以如果要用，请使用包装类型。

66.asList方法产生的List对象不可更改

        Integer[] data = new Integer[5];
        for (int i = 0; i < 5; i++) {
            data[i] = new Random().nextInt(10);
        }
        List<Integer> mList = Arrays.asList(data);
        mList.add(2);

java.lang.RuntimeException: Unable to start activity ComponentInfo
{old.pkg.com.myapplicati/newpkg.pkg.com.myapplication2.MainActivity}: java.lang.UnsupportedOperationException
at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2279)
at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2329)
at android.app.ActivityThread.access$1100(ActivityThread.java:141)
at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1242)

因为通过asList产生的List不同于正常使用的List，不能使用add remove方法。

只有size toArray get set contains五个方法可以用。

List mList = Arrays.asList(1, 2, 3);这种方式生成数组有巨大的隐患。

67.不同的列表选择不同的遍历方法

        new Thread(new Runnable() {
            @Override
            public void run() {
                List<Integer> mList = new ArrayList<>();
                for (int i = 0; i < 80 * 100; i++) {
                    mList.add(new Random().nextInt(200));
                }
                long start = System.currentTimeMillis();
                int average = CldArrayUtil.average(mList);

                Log.i("clp", "time =" + (System.currentTimeMillis() - start) + "ms");
                Log.i("clp", "average=" + average);

                List<Integer> mList2 = new LinkedList<>();
                for (int i = 0; i < 80 * 100; i++) {
                    mList2.add(new Random().nextInt(200));
                }
                long start2 = System.currentTimeMillis();
                int average2 = CldArrayUtil.average(mList2);

                Log.i("clp", "time2 =" + (System.currentTimeMillis() - start2) + "ms");
                Log.i("clp", "average2=" + average2);
            }
        }).start();

使用fori循环

    //求平局数
    public static int average(List<Integer> list) {
        int sum = 0;
        for (int i = 0; i < list.size(); i++) {
            sum += list.get(i);
        }
        return sum / list.size();
    }

01-05 21:07:22.310 2140-2188/old.pkg.com.myapplicati I/clp: time =8ms

01-05 21:07:22.310 2140-2188/old.pkg.com.myapplicati I/clp: average=98

01-05 21:07:23.280 2140-2188/old.pkg.com.myapplicati I/clp: time2 =929ms

01-05 21:07:23.280 2140-2188/old.pkg.com.myapplicati I/clp: average2=98

8000个就是快1S,80万个就是100S!!!!

    //求平局数
    public static int average(List<Integer> list) {
        int sum = 0;
//        for (int i = 0; i < list.size(); i++) {
//            sum += list.get(i);
//        }
        for (Integer i : list) {
            sum += i;
        }
        return sum / list.size();
    }

01-05 21:09:06.990 3137-3185/old.pkg.com.myapplicati I/clp: time =5ms

01-05 21:09:06.990 3137-3185/old.pkg.com.myapplicati I/clp: average=99

01-05 21:09:07.030 3137-3185/old.pkg.com.myapplicati I/clp: time2 =9ms

01-05 21:09:07.030 3137-3185/old.pkg.com.myapplicati I/clp: average2=98

在手机上测试，使用foreach方法，消耗的时间差不多???

ArrayList实现了随机读取(RandomAcess)，而LinkedList实现了迭代器。

书上建议通过判断是否有RandomAcess

    //求平局数
    public static int average(List<Integer> list) {
        int sum = 0;
        if (list instanceof RandomAccess) {//针对ArrayList可以随机读取的
            for (int i = 0; i < list.size(); i++) {
                sum += list.get(i);
            }
        } else {//针对LinkedList这种
            for (Integer i : list) {
                sum += i;
            }
        }
        return sum / list.size();
    }

01-05 21:11:53.070 4250-4304/old.pkg.com.myapplicati I/clp: time =4ms

01-05 21:11:53.070 4250-4304/old.pkg.com.myapplicati I/clp: average=98

01-05 21:11:53.130 4250-4304/old.pkg.com.myapplicati I/clp: time2 =12ms

01-05 21:11:53.130 4250-4304/old.pkg.com.myapplicati I/clp: average2=98

68.频繁插入和删除时用LinkedList

ArrayList和LinkedList性能比较

添加:

        new Thread(new Runnable() {
            @Override
            public void run() {
                List<String> mArrayList = new ArrayList<String>();
                for (int i = 0; i < 10; i++) {
                    mArrayList.add("a");
                }
                long start = System.currentTimeMillis();
                for (int i = 0; i < 100000; i++) {
                    mArrayList.add(2, "a");
                }
                Log.i("clp", "array list time =" + (System.currentTimeMillis() - start) + "ms");
                List<String> mLinkedList = new LinkedList<String>();

                for (int i = 0; i < 10; i++) {
                    mLinkedList.add("a");
                }
                long start2 = System.currentTimeMillis();
                for (int i = 0; i < 100000; i++) {
                    mLinkedList.add(2, "a");
                }
                Log.i("clp", "linked list time =" + (System.currentTimeMillis() - start2) + "ms");

            }
        }).start();

01-05 21:34:13.060 10127-10170/old.pkg.com.myapplicati I/clp: array list time =15847ms

01-05 21:34:13.170 10127-10170/old.pkg.com.myapplicati I/clp: linked list time =116ms

10万个数据的话，相差100倍。

删除:

        new Thread(new Runnable() {
            @Override
            public void run() {
                List<String> mArrayList = new ArrayList<String>();
                for (int i = 0; i < 10 * 10000; i++) {
                    mArrayList.add("a");
                }
                long start = System.currentTimeMillis();
                while (mArrayList.size() > 0){
                    mArrayList.remove(0);
                }
                Log.i("clp", "array list time =" + (System.currentTimeMillis() - start) + "ms");
                List<String> mLinkedList = new LinkedList<String>();

                for (int i = 0; i < 10 * 10000; i++) {
                    mLinkedList.add("a");
                }
                long start2 = System.currentTimeMillis();
                while (mLinkedList.size() > 0) {
                    mLinkedList.remove(0);
                }
                Log.i("clp", "linked list time =" + (System.currentTimeMillis() - start2) + "ms");

            }
        }).start();

01-05 21:37:58.600 11330-11372/old.pkg.com.myapplicati I/clp: array list time =15108ms

01-05 21:37:58.700 11330-11372/old.pkg.com.myapplicati I/clp: linked list time =13ms

删除，性能相差1000倍。

修改:

        new Thread(new Runnable() {
            @Override
            public void run() {
                List<String> mArrayList = new ArrayList<String>();
                for (int i = 0; i < 10 * 10000; i++) {
                    mArrayList.add("a");
                }
                long start = System.currentTimeMillis();
                for (int i = 0; i < 10 * 10000; i++) {
                    mArrayList.set(10000, "b");
                }
                Log.i("clp", "array list time =" + (System.currentTimeMillis() - start) + "ms");
                List<String> mLinkedList = new LinkedList<String>();

                for (int i = 0; i < 10 * 10000; i++) {
                    mLinkedList.add("a");
                }
                long start2 = System.currentTimeMillis();
                for (int i = 0; i < 10 * 10000; i++) {
                    mLinkedList.set(10000, "b");
                }
                Log.i("clp", "linked list time =" + (System.currentTimeMillis() - start2) + "ms");

            }
        }).start();

01-05 21:40:26.700 12467-12523/old.pkg.com.myapplicati I/clp: array list time =28ms

01-05 21:40:55.580 12467-12523/old.pkg.com.myapplicati I/clp: linked list time =28672ms

总结:频繁的删除和插入，使用LinkedList。如果频繁的获取和修改。使用ArrayList

69.列表相等只需关系元素数据

判断集合是否相等时，只需要判断元素是否相等即可。

        ArrayList<String> mList = new ArrayList<String>();
        mList.add("a");

        Vector<String> mVList = new Vector<String>();
        mVList.add("a");

        Log.i("clp", "is equals =" + mList.equals(mVList));

01-06 06:56:50.610 25692-25692/old.pkg.com.myapplicati I/clp: is equals =true

equals是在AbstractList中实现的，代码如下:

    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof List))
            return false;

        ListIterator<E> e1 = listIterator();
        ListIterator e2 = ((List) o).listIterator();
        while (e1.hasNext() && e2.hasNext()) {
            E o1 = e1.next();
            Object o2 = e2.next();
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }
        return !(e1.hasNext() || e2.hasNext());
    }

70.子列表只是原列表的一个视图

        List<String> mlist = new ArrayList<String>();
        mlist.add("A");
        mlist.add("B");
        ArrayList<String> mBList = new ArrayList<>(mlist);

        List<String> mCList = mlist.subList(0, mlist.size());
        mCList.add("C");

        Log.i("clp", "mlist mBlist is equals =" + mlist.equals(mBList));
        Log.i("clp", "mlist mCList is equals =" + mlist.equals(mCList));

01-06 07:18:39.990 29976-29976/old.pkg.com.myapplicati I/clp: mlist mBlist is equals =false

01-06 07:18:39.990 29976-29976/old.pkg.com.myapplicati I/clp: mlist mCList is equals =true

subList是在原数组上进行操作。

71.推荐使用subList处理局部列表

        List<String> mList = new ArrayList<String>();
        for (int i = 0; i < 100; i++) {
            mList.add("a");
        }
        //删除第20~30之间的元素
        mList.subList(20, 30).clear();
        Log.i("clp", "mList size =" + mList.size());

01-06 07:28:51.470 32234-32234/old.pkg.com.myapplicati I/clp: mList size =90

72.生成子列表之后不要再操作原列表

        List<String> mList = new ArrayList<String>();
        for (int i = 0; i < 100; i++) {
            mList.add("a");
        }
        List<String> mSubList = mList.subList(20, 30);
        mList.add("d");
        Log.i("clp", "mlist size =" + mList.size());
        Log.i("clp", "mSubList size =" + mSubList.size());

java.lang.RuntimeException: Unable to start activity ComponentInfo

{old.pkg.com.myapplicati/newpkg.pkg.com.myapplication2.MainActivity}:

java.util.ConcurrentModificationException

操作子列表也有可能导致报错，如下:

        List<String> mList = new ArrayList<String>();
        for (int i = 0; i < 100; i++) {
            mList.add("a");
        }
        List<String> mSubList = mList.subList(20, 30);
        List<String> mSubList2 = mList.subList(10, 30);
        mSubList.add("d");
//        mSubList2.add("e");
        Log.i("clp", "mlist size =" + mList.size());
        Log.i("clp", "mSubList size =" + mSubList.size());
        Log.i("clp", "mSubList2 size =" + mSubList2.size());

73.使用Comparator进行排序

public class Person implements Comparable<Person> {

    public int id;
    public String name;

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

    @Override
    public int compareTo(Person person) {
        if (person == null) {
            return -1;
        }
        return Integer.valueOf(id).compareTo(Integer.valueOf(person.id));
    }
}

        List<Person> mList = new ArrayList<Person>();
        mList.add(new Person(2, "张二"));
        mList.add(new Person(1, "张一"));
        mList.add(new Person(4, "张四"));
        mList.add(new Person(3, "张三"));
        Collections.sort(mList);
        for (int i = 0; i < mList.size(); i++) {
            Log.i("clp", "index =" + i + ";name =" + mList.get(i).name);
        }

使用Comparator可以拓展排序。

        List<Person> mList = new ArrayList<Person>();
        mList.add(new Person(2, 440300, "张二"));
        mList.add(new Person(1, 440322, "张一"));
        mList.add(new Person(4, 440310, "张四"));
        mList.add(new Person(3, 440200, "张三"));
        mList.add(new Person(6, 440200, "张六"));
        mList.add(new Person(5, 440200, "张五"));
        Collections.sort(mList, new PerComparator());
        for (int i = 0; i < mList.size(); i++) {
            Log.i("clp", "index =" + i + ";cityId=" + mList.get(i).cityId + ";name =" + mList.get(i).name);
        }

    //先按照cityId进行排序，如果相等，就按照id排序
    public class PerComparator implements Comparator<Person> {
        @Override
        public int compare(Person person, Person t1) {
            if (person.cityId > t1.cityId) {//1的画，是排后面
                return 1;
            } else if (person.cityId == t1.cityId) {//如果城市相等，按照id排序
                if (person.id > t1.id) {
                    return 1;
                } else if (person.id == t1.id) {
                    return 0;
                } else {
                    return -1;
                }
            } else {
                return -1;
            }
        }
    }

如果想实现倒序，直接使用:

Collections.sort(mList, Collections.reverseOrder(new PerComparator()));

    Collections.reverse(mList);---对排序之后的，进行倒序

Comparable实现默认排序。Comparator可以实现拓展排序。

74.不推荐使用binarySearch对列表进行检索

1.indexOf是通过for循环进行排序查找第一个符合条件的

2.binarySearch是通过二分查找，但是前提也是必须先排序

所以，如果已经排序的，使用binarySearch性能会高很多。

75.集合中的元素必须做到compartTo和equals同步

public class Person implements Comparable<Person> {

    public int id;
    public String name;

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

    @Override
    public int compareTo(Person person) {
        if (person == null) {
            return -1;
        }
        return person.name.compareTo(this.name);
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (o == this) {
            return true;
        }
        if (this.getClass() != o.getClass()) {
            return false;
        }
        Person p = (Person) o;
        return Integer.valueOf(id).compareTo(Integer.valueOf(p.id)) == 0;
    }
}

        List<Person> mList = new ArrayList<Person>();
        mList.add(new Person(1, "张二"));
        mList.add(new Person(1, "张一"));

        Person p = new Person(1, "张一");
        int index1 = mList.indexOf(p);
        int index2 = Collections.binarySearch(mList, p);
        Log.i("clp", "index1=" + index1);
        Log.i("clp", "index2=" + index2);

04-18 11:51:12.192 12423-12423/com.example.demo I/clp: index1=0

04-18 11:51:12.192 12423-12423/com.example.demo I/clp: index2=1

indexOf是通过对象中的equals来判断是否相等，

binarySearch是通过compartTo来判断是否相等。所以2个方法应该同步。

76.集合运算中使用更优雅的方式

        List<String> mList1 = new ArrayList<String>();
        mList1.add("a");
        mList1.add("b");
        List<String> mList2 = new ArrayList<String>();
        mList2.add("a");
        mList2.add("c");

        //并集
//        mList1.addAll(mList2);
//        Log.i("clp", "并集 size=" + mList1.size());
//        //04-18 12:07:46.552 12423-12423/com.example.demo I/clp: 并集 size=4

        //交集
//        mList1.retainAll(mList2);
//        Log.i("clp", "交集 size=" + mList1.size());
        //04-18 12:08:55.022 12423-12423/com.example.demo I/clp: 交集 size=1

        //差集
//        mList1.removeAll(mList2);
//        Log.i("clp", "差集 size=" + mList1.size());
        //04-18 12:09:44.782 12423-12423/com.example.demo I/clp: 差集 size=1

        //无重复的并集
        mList2.removeAll(mList1);
        mList1.addAll(mList2);
        Log.i("clp", "无重复的并集 size=" + mList1.size());
//        04-18 12:10:34.862 12423-12423/com.example.demo I/clp: 无重复的并集 size=3

无重复的并集，不能使用HashSet，因为会把本来重复的元素合并掉。

77.使用shuffle打乱列表

        int count = 10;
        List<String> mList = new ArrayList<>(10);
        for (int i = 0; i < 10; i++) {
            mList.add(i + "");
        }
//        for (int i = 0; i < 10; i++) {
//            int random = new Random().nextInt(10);
//            Collections.swap(mList, i, random);
//        }
        Collections.shuffle(mList);//打乱顺序
        for (int i = 0; i < 10; i++) {
            Log.i("clp", "value" + mList.get(i));
        }

78.减少HashMap中元素的数量

1.比ArrayList多了Entry对象，如果有40万个数据，就是多了40万个对象

2.扩容机制不一样，HashMap是2倍扩容，ArrayList是1.5倍

3.HashMap有一个加载因子，意思是到达容量的0.75就开始扩容了

所以大量数据的时候，HashMap比ArrayList先内存溢出。

79.集合中的哈希码尽量不要重复

HashMap是通过哈希值，实现比ArrayList快速的查找，如果哈希码是一样的，性能就和链表的性能是一样的。

80.多线程使用Vector和HashTable

        final Vector<String> mVList = new Vector<String>();
        for (int i = 0; i < 10000; i++) {
            mVList.add("火车票" + i);
        }
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        String mR = mVList.remove(0);
                        Log.i("clp", "cur thread id=" + Thread.currentThread().getId() + ";remove =" + mR);
                    }
                }
            }).start();
        }

多个线程同步，但是不能实现，一个线程读的时候，另一个线程在写。

81.非稳定序列推荐使用List

        SortedSet<Person> sortSet = new TreeSet<Person>();
        sortSet.add(new Person(15, "张三"));
        sortSet.add(new Person(10, "张四"));
        for (Person per : sortSet) {
            Log.i("clp", "id=" + per.id + ";name=" + per.name);
        }

04-18 15:44:55.202 31018-31018/com.example.demo I/clp: id=10;name=张四

04-18 15:44:55.202 31018-31018/com.example.demo I/clp: id=15;name=张三

        SortedSet<Person> sortSet = new TreeSet<Person>();
        sortSet.add(new Person(15, "张三"));
        sortSet.add(new Person(10, "张四"));
        sortSet.first().id = 20;
        for (Person per : sortSet) {
            Log.i("clp", "id=" + per.id + ";name=" + per.name);
        }

04-18 15:45:49.532 31018-31018/com.example.demo I/clp: id=20;name=张四

04-18 15:45:49.532 31018-31018/com.example.demo I/clp: id=15;name=张三

SortedSet只有在插入的时候，进行排序。

    sortSet = new TreeSet<Person>(new ArrayList<Person>(sortSet));

可以通过new 重新构建。

基本类型，建议使用SortedSet，如果是自己创建的对象，可以使用Colletions.sort

82.集合大家族

一、List

实现List的接口主要有:ArrayList-动态数组 LinkedList-双向链表 Vector-线程安全的动态数组 Stack-对象栈，先进后出

二、Set-不包含重复元素的集合:

EnumSet-枚举类型的专用Set，所有的元素都是枚举类型

HashSet-以哈希码决定元素位置的Set，与HashMap类似，提供快速的插入和查找

TreeSet-自动排序的Set，实现了SortedSet接口

三、Map-分为排序的Map和非排序Map

TreeMap-根据Key值自动排序

HashMap

HashTable

Properties:HashTable的子类，主要从Property文件中加载数据，并提供方便的读写。

EnumMap

WeakHashMap:可以被垃圾回收的HashMap

四、Queue队列-分为阻塞和非阻塞队列

五、数组

所有的集合底层存储的都是数组，数据可以存储基本类型，集合不行。

六、工具类

数组的工具类:Array和Arrays

集合的工具类:Collections

如果需要精确排序，则需要使用开源项目。如pinyin4j。

枚举和注解

83.推荐使用枚举定义常亮

public enum SeaSon {
    Sping, Summer, Autumn, Winner;

    public static SeaSon getCommonSeason() {
        return Sping;
    }

}

        for (SeaSon s : SeaSon.values()) {
            Log.i("clp", "s values =" + s);
        }

        Log.i("clp", "common =" + SeaSon.getCommonSeason());

04-19 10:26:24.608 14196-14196/com.example.demo I/clp: s values =Sping

04-19 10:26:24.608 14196-14196/com.example.demo I/clp: s values =Summer

04-19 10:26:24.608 14196-14196/com.example.demo I/clp: s values =Autumn

04-19 10:26:24.608 14196-14196/com.example.demo I/clp: s values =Winner

04-19 10:26:24.608 14196-14196/com.example.demo I/clp: common =Sping

84.使用构造函数协助描述枚举项

public enum SeaSon {
    Sping("春"), Summer("夏"), Autumn("秋"), Winner("冬");

    private String desc;

    SeaSon(String desc) {
        this.desc = desc;
    }

    public String getDesc() {
        return desc;
    }

    public static SeaSon getCommonSeason() {
        return Sping;
    }

}

        for (SeaSon s : SeaSon.values()) {
            Log.i("clp", "s values =" + s.getDesc());
        }

        Log.i("clp", "common =" + SeaSon.getCommonSeason());

构造函数还可以比这个更复杂，传递对象等。

85.小心switch带来的空值异常

    public void doSwSeaSon(SeaSon seaSon) {
        switch (seaSon) {
            case Sping:
                Log.i("clp", "Sping");
                break;
            default:
                Log.i("clp", "其他类型");
                break;
        }
    }

doSwSeaSon(null);

java.lang.NullPointerException: Attempt to invoke virtual method ‘int com.cp.demo.java.SeaSon.ordinal()’ on a null object reference

case的其实是:SeaSon.Sping.ordinal(),所以要做对象的空值判断。

86.在switch的default代码块中增加AssertionError错误

因为枚举类型和case没有强制关系，如果后续增加了一个，没有case，就会导致switch漏掉这个枚举项。

87.枚举使用valueOf前必须进行校验

否则会抛出异常

        List<String> mList = Arrays.asList("Sping", "sss");
        for (int i = 0; i < mList.size(); i++) {
            SeaSon sea = SeaSon.valueOf(mList.get(i));
            if (sea == null) {
                Log.i("clp", "没有此枚举值");
            } else {
                Log.i("clp", "有值");
            }
        }

java.lang.IllegalArgumentException: sss is not a constant in com.cp.demo.java.SeaSon

两种方案:

1.捕获异常

        List<String> mList = Arrays.asList("Sping", "sss");
        for (int i = 0; i < mList.size(); i++) {
            try {
                SeaSon sea = SeaSon.valueOf(mList.get(i));
                Log.i("clp", "有值");
            } catch (IllegalArgumentException e) {
                Log.i("clp", "没有此枚举值");
            }
        }

04-19 11:35:20.148 13538-13538/com.example.demo I/clp: 有值

04-19 11:35:20.148 13538-13538/com.example.demo I/clp: 没有此枚举值

2.拓展枚举类

    public static boolean contains(String name) {
        for (SeaSon sen : values()) {
            if (sen.name().equals(name)) {
                return true;
            }
        }
        return false;
    }

        List<String> mList = Arrays.asList("Sping", "sss");
        for (int i = 0; i < mList.size(); i++) {
            boolean sea = SeaSon.contains(mList.get(i));
            if (sea) {
                Log.i("clp", "有值");
            } else {
                Log.i("clp", "没有此枚举值");
            }
        }

88.用枚举实现工厂方法模式更简洁

1.非静态方法实现。

public interface Car {
    public void drive();
}

public class FortCar implements Car {

    @Override
    public void drive() {
        Log.i("clp", "fort drive");
    }
}

public class BuickCar implements Car {

    @Override
    public void drive() {
        Log.i("clp", "buick drive");
    }
}

public enum CarFactory {
    FortCar, BuickCar;

    public Car create() {
        switch (this) {
            case FortCar:
                return new FortCar();
            case BuickCar:
                return new BuickCar();
            default:
                Log.i("clp", "无效参数");
        }
        return null;
    }

}

04-19 11:55:34.988 1940-1940/com.example.demo I/clp: fort drive

2.通过抽象方法生成

public enum CarFactory {
    FortCar {
        @Override
        public Car create() {
            return new FortCar();
        }
    }, BuickCar {
        @Override
        public Car create() {
            return new BuickCar();
        }
    };

    public abstract Car create();

}

89.枚举项的数量限制的64个以内

long e = -1L >>> -65;//value=1
long e = -1L >>> -1;//value=1
long e = -1L >>> 63;//value=1
long e = -1L >>> 1;//9223372036854775807

long e = -1L >>> 62;//value=3

int e = -1 >>> 31;//value=1
int e = -1 >>> 1;//2147483647

小于等于64和大于64处理的机制是不一样的。

        Enum[] universe = getUniverse(elementType);
        if (universe == null)
            throw new ClassCastException(elementType + " not an enum");

        if (universe.length <= 64)
            return new RegularEnumSet<>(elementType, universe);
        else
            return new JumboEnumSet<>(elementType, universe);

RegularEnumSet:
    void addAll() {
        if (universe.length != 0)
            elements = -1L >>> -universe.length;
    }

JumboEnumSet:
    void addAll() {
        for (int i = 0; i < elements.length; i++)
            elements[i] = -1;
        elements[elements.length - 1] >>>= -universe.length;
        size = universe.length;
    }

所以内部是以64位拆分进行分组。

90.小心注解继承

91.枚举和注解结合使用威力很大

92.注意@Overrig不同版本的区别

如果是Java1.6版本的程序移植到1.5版本环境中，就需要删除实现接口方法上的@Override注解

泛型和反射

93.Java的泛型是类型擦除的

java的编译期和运行期解读:

http://www.360doc.com/content/14/0218/23/9440338_353675002.shtml

编译期:源码->class文件的过程

运行期:在JVM中运行的过程

    public void initList(List<Integer> mList) {

    }

    public void initList(List<String> mList) {

    }

按照上面这种方式写，报错。

initList(List)’ clashes with ‘initList(List)’; both methods have same erasure

        List<String> mList = new ArrayList<String>();
        List<Integer> mIList = new ArrayList<Integer>();
        Log.i("clp", "is equals=" + (mList.getClass() == mIList.getClass()));

04-25 15:49:13.356 2760-2760/old.pkg.com.myapplicati I/clp: is equals=true

他们擦除后的类型都是List

Java泛型－类型擦除:

http://blog.csdn.net/caihaijiang/article/details/6403349

94.不能初始化泛型参数和数组

        T t = new T();//报错
        T[] mTArray = new T[];//报错
        List<T> mList = new ArrayList<T>();//报错

以上3个写法，在AS上面都报错，需要在运行期指定T类型。

95.强制声明泛型的实际类型

List<Integer> mList = CldCalMiniUtil.asList();//正确
List<Integer> mList = CldCalMiniUtil.<Integer>asList();//正确
List<Number> mList2 = CldCalMiniUtil.asList(1, 2.2);//报错
List<Number> mList2 = CldCalMiniUtil.<Number>asList(1, 2.2);//正确--这里使用了强制声明

时间： 2024-11-08 08:38:35