编写高质量代码:改善Java程序的151个建议-学习笔记(1-4章)
2017-05-06 00:01
1031 查看
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”, “基本类型的方法被调用”);
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 =newpkg.pkg.com.myapplication2.algorithm.Person@bd2e9
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 =是
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-8try { 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。
相关文章推荐
- 编写高质量代码:改善Java程序的151个建议-学习笔记(1-4章)
- 编写高质量代码:改善Java程序的151个建议-学习笔记(9-12章)
- 编写高质量代码:改善Java程序的151个建议-学习笔记(5-8章)
- 《编写高质量代码改善Java程序的151个建议》学习笔记 第6章 枚举和注解
- 编写高质量代码:改善java程序的151个建议-----笔记(1)
- 读编写高质量代码--改善java程序的151个建议笔记
- 笔记:编写高质量代码 改善Java程序的151个建议
- [编写高质量代码:改善java程序的151个建议]建议43 避免对象浅拷贝; 建议44:推荐使用序列化实现对象的深拷贝
- [编写高质量代码:改善java程序的151个建议]建议35:不要在类中初始化其他类
- 编写高质量代码++改善Java程序的151个建议
- [编写高质量代码:改善java程序的151个建议]建议58 强烈建议使用UTF-8编码
- [编写高质量代码:改善java程序的151个建议]建议53 注意方法中传递的参数要求
- [编写高质量代码:改善java程序的151个建议]建议62 警惕数组的浅拷贝
- 编写高质量代码:改善Java程序的151个建议 (第2章 基本类型)
- 编写高质量代码:改善Java程序的151个建议 (第3章 类、对象及方法)
- [编写高质量代码:改善java程序的151个建议]建议34:构造函数尽量简化
- 编写高质量代码:改善Java程序的151个建议