数据类型:一组值以及可以对其执行的操作。分为基本数据类型(小写字母开头)和对象数据类型(大写字母开头)
Object是所有类的父类,有时只能使用可变的数据类型(例如容器中使用.valueOf方法),基本类型对应的对象数据类型如下:
Integer, Long, Byte, Short, Character, Float, Double, Boolean,一般情况下避免使用,会降低性能。
类型转换例子:
int a = (int) 18.7; //a = 18 double a = (double) 2/3; //a = 0.6666... int a = 18.7; //ERROR String n = 1; //ERROR double a = 2/3; //a = 0.0
Java是一种静态类型语言,Python是一种动态类型语言。这里一定要弄清楚它俩的概念,不然容易与动态检查与静态检查弄混。
静态类型语言是指所有的变量在编译时已知,所以编译器能推导出表达式类型,所以就可以在编译阶段进行类型检查的语言。例如a和b都被声明为int,那么编译器知道a + b的类型也是int。
动态类型语言是在运行阶段才进行类型检查的。
静态检查是指在运行前检查bug(最好的检查),动态检查是指在运行时检查bug。还有一种就是不检查。
静态检查:语法错误,类名/函数名错误,参数数目错误,参数类型错误,返回值类型错误。检查静态类型语言时,会进行类型和语法错误的检查,不考虑值;检查动态类型语言时,只检查是否有语法错误。
动态检查:非法的参数值,非法的返回值,越界,空指针。关于值的检查
浮点类型数的特殊值:NaN, POSITIVE_INFINITY, NEGATIVE_INFINITY
下面举几个错误的例子:
int n = 5; if (n) n = n + 1;
编译会出现这样的错误:
error: incompatible types: int cannot be converted to boolean
if (n)
^
这就属于静态错误。
int big = 200000; big = big * big; System.out.println(big);
这个不仅编译不会报错,运行的时候也不会报错,但是输出的结果是不对的,因为它溢出了,计算机无法检测出来。
int sum = 0; int n = 0; int average = sum / n;
这是0除以0,是很明显的错误,编译阶段依然可以通过,而运行时才会报错,可见静态检查只是对类型的检查,不会检查值是什么,符合就可以。而动态检查就是对值的检查。
下面的例子是一个比较令人困惑的例子。
double sum = 7; double n = 0; double average = sum / n; System.out.println(average);
把例子换成了double类型的变量,结果就不同了,原因就在于浮点数中的0在计算机中表示的是无限接近于它的极小的数,所以除以得到无穷。
可变类型和不可变类型的区别在于能否改变变量的值,也就是能否改变变量指向的存储空间中的值。
改变一个变量的意思是把这个变量指向别的存储空间。
而在定义变量时,前面加上关键字final的作用就是使这个变量不可变,由此我们也能够知道,对于不可变类型,例如int,当用final修饰它的时候,在它的作用域之内就是真的不可变了,无法改变值,也不能令它指向其它空间。但用final修饰Integer这种可变类型变量的话,仍然可以改变它的值。
final修饰class的话,就表明这个类无法派生子类;
final修饰一个方法的话,在这个类的子类中,这个方法就无法被重写。
对于不可变的String的更改如下所示
String s = "a";
s = s.concat("b");
对于可变的StringBuilder如下所示:
StringBuilder sb = new StringBuilder("a");
sb.append("b");
通过以上分析,能够看出,不可变类型进行更改时会指向新的存储空间(如果原来的存储空间没有变量指向时,就会被回收),而可变类型会在原来的存储空间内改变值。对于一个存储空间只有一个引用时,这两种方法没有区别,但是如果是有多个引用指向同一空间,差异就出现了。
String s = "a";
s = s.concat("b");
StringBuilder sb = new StringBuilder("a");
sb.append("b");
String t = s;
t = t + "c";
StringBuilder tb = sb;
tb.append("c");
这段代码对应的快照图如下:
以上可以看出,当对t进行更改时,会创建新的拷贝,所以s指向的值不会改变,而对于可变类型,对tb进行更改,由于sb和tb指向同一内存空间,所以引用sb时,它的值也发生了改变。
所以相对于不可变类型,可变类型至少有以下几条优点:
1. 当频繁修改时,不会产生大量的临时拷贝,就不需要进行垃圾回收,通过最小化拷贝,能够提高效率。
2. 相当于全局变量,它更适合在多个模块之间共享数据
再看一段代码:
String s = " Hello "; s += " World "; s.trim(); System.out.println(s);
trim()方法是返回一个去掉空格的副本,通过以上不可变类型的知识可知,s指向的存储空间是不会受到影响的,整个过程产生两个垃圾需要回收,所以快照图如下。
正所谓我们应当辩证地去看待事物,可变类型同样有很大的缺点:它的安全性很差,比如我们本地的变量如果泄露出去的话,外部模块对其进行更改,我们本地进行引用时同样会改变。同时多个引用交错使用,会让我们更难理解程序的真实意图是什么,也就更难实现规约。
下面看两个例子
(1)先看这段代码:
public static int sum(Listlist){ int sum = 0; for(int x : list) sum += x; return sum; } public static int sumAbsolute(List list) { // let's reuse sum(),because DRY,so first we take absolute values for(int i= 0; i myData=Arrays.asList(-5,-3,-2); System.out.println(sumAbsolute(myData)); System.out.println(sum(myData)); }
单独看计算和方法和计算绝对值之和方法都没有任何问题,但是一旦先调用了计算绝对之和方法,其中的Math.abs()方法会把里面的元素改为它的绝对值,并且仍然放在其中,这就导致main函数中的mydata发生改变,进而之后再对其进行其他操作就会出错。这是一个潜在的错误,编译和运行阶段都不会报错,我们很难跟踪与发现。所以在今后的设计中我们尽量不要传递可变对象。
再看另一个例子。首先说明Date是Java中内置的类,是可变类型的。
public static Date startofSpring() {
if(groundhogAnswer == null) groundhogAnswer = askGroundhog();
return groundhogAnswer;
}
private static Date groundhogAnswer = null;
// somewhere else in the code...
public static void partyPlanning(){
// let's have a party one month after spring starts!
Date partyDate = startOfSpring();
partyDate.setMonth(partyDate.getMonth()+ 1);
//... uh-oh. what just happened?
}
由于startofSpring把现在的日期直接返回给了partyDate变量,这样,当改变partyDate时,groundhogAnswer就也被改变。当以后再访问startofSpring,就会返回April而不是March。快照图如下:
想要使上述问题不在出现,可以通过防御式拷贝,返回给客户端全新的Date对象,这样当客户端对其进行修改时,就不会导致方法出现问题。
return new Date(groundhogAnswer.getTime());
但实际上很多时候客户端不会修改得到的数,这就会造成大量的内存浪费,所有更好的解决办法还是使用不可变类型,这样就不再需要防御式拷贝了。我们应该选择安全地使用可变类型,让它作为局部变量,只有一个引用,不涉及进行共享,这样就解决安全问题。
在这里说一下快照图的概念,它是用来描述程序运行某一时刻的内部状态的图,便于程序员之间的交流,便于刻画各类变量随时间变化,便于解释设计思路。
对于基本类型的值就直接是箭头指向,如下:
如果是对象类型的值,如果指向可变类型,需要用一个椭圆包起来,然后里面的各个域再指向其对应的值,例如一个Point类型的snapshot如下:
如果指向一个不可变类型,椭圆就需要用双线的
除此之外,在以上的基础上,如果是一个不可变的引用,那么就需要采用双线箭头
复杂数据类型:数组和容器
数组:
定长数组:
int[] a = new int[100];
动态数组:不能放入基本类型。.get(index), .set(index, value), .size()
Listlist = new ArrayList<>();
相对于List,Set接口保存的是无序且互异的集合。.contanins(e), .containsAll(s2), .removeAll(s2)
Map接口类似于字典。.put(key, value), .get(key), .containsKey(key), .remove(key)。快照图如下:
对于List, Set, Map的实现:ArrayList, LinkedList, HashSet, HashMap
并行修改的错误,在遍历时,同时修改index并且删除里面的元素,可能会出现错误,可以使用迭代器的.remove()方法。
不可变的数据类型:基本类型及其封装对象类型,BigInteger,BigDecimal, LocalDateTime, Instant
对于容器类型防止安全泄露的方法,除了防御式拷贝,还可以使用
//分别作为List, Set, Map类型的返回值 Collections.unmodifiableList(list); Collections.unmodifiableSet(set); Collections.unmodifiableMap(map);
这是一种包装器的方法,使得传输出去的容器(注意不是它的副本)只能被看。但缺点是这种“不可变”是在运行阶段获得的,编译阶段无法据此进行静态检查。



