基本数据类型
Java的数据类型分为两类：
- 基本数据类型：整数、浮点数、字符、布尔。
- 引用数据类型：数组、字符串、类、接口、Lambda。
基本数据类型
- 字节型：byte，1个字节
- 短整型：short，2个字节
- 整型：int，4个字节（默认）
- 长整型：long，8个字节（建议定义时加L表示
long a = 12345678L;） - 单精度浮点数：float，4个字节（建议定义时加F表示
float a = 10.2F;） - 双精度浮点数：double，8个字节（默认）
- 字符型：char，2个字节（单引号表示
byte A = 'A';） - 布尔型：boolean，1个字节
两个特例
例1：
short s = 1;
s += 1;
System.out.println(s);
正常来说，1是整型，s是short型，会出错。但是+=是运算法，只计算一次，并带有强制转换的特点，所以不会出错。
例2：
byte b1 = 1;
byte b2 = 2;
byte b3 = 1 + 2;
byte b4 = b1 + b2;
b3不会出错，因为b3是在1+2计算完成之后再赋值；b4会出错，因为b1+b2有可能超出b4的范围。
数组
数组是引用数据类型，数组需要指定长度和存储数据类型。
数组初始化方法：
- 动态初始化（指定长度）：
int[] arr = new int[3] - 静态初始化（指定内容）：
char[] arr = new char[]{'a', 'b', 'c'} - 省略格式的静态初始化：
int[] arr = {1, 2, 3}
包装类
基本数据类型在于效率，引用数据类型可以提供更多功能。把基本数据类型装起来，称为包装类，两个过程：装箱/拆箱。
装箱：
Integer i1 = new Integer(4); // 构造方法
Integer i2 = Integer.valueOf(4); // 类中的方法
拆箱：
int num = i.intValue();
JAVA5之后，可以自动装箱拆箱：
Integer i = 4; // 自动装箱
int a = i + 5; // <==> int a = i.intValue() + 5;
基本数据类型都可以通过包装类和字符串转换
String s1 = 100 + ""; // 第一种方式
String s2 = Integer.toString(100); // 第二种方式
String s3 = String.valueOf(100); // 第三种
int a = Integer.parseInt(s1);
泛型
未知的数据类型，可以应用于类、方法、接口。
类：
public class Test {
public static void main(String[] args) {
Person<String> p = new Person<>();
p.setName("字符串");
System.out.println(p.getName());
}
}
class Person<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
方法：
public class Test {
public static void main(String[] args) {
// 方法
Person p = new Person();
p.method1(100);
p.method1("字符串");
// 静态方法
Person.method2("任意数据类型");
}
}
class Person {
public <M> void method1(M m) {
System.out.println(m);
}
public static <S> void method2(S s) {
System.out.println(s);
}
}
接口：
public class Test {
public static void main(String[] args) {
TestImp<String> t = new TestImp<>();
t.method("字符串");
}
}
interface TestInterface<E> {
public abstract void method(E e);
}
class TestImp<E> implements TestInterface<E> { // 这里可以指定，也可以不指定泛型
public void method(E e) {
System.out.println(e);
}
}
泛型的通配符
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
ArrayList<String> list2 = new ArrayList<>();
list2.add("a");
list2.add("b");
printArray(list1);
printArray(list2);
}
public static void printArray(ArrayList<?> list) {
for (Object x : list) {
System.out.println(x);
}
}
}
泛型的上限限定：? extends E 代表使用的泛型只能是E类型的子类或本身
泛型的下限限定：? super E 代表使用的泛型之只能是E类型的父类或本身
比如：Object类，String 类，Number类，Integer类，其中Number是Integer的父类
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();
Collection<String> list2 = new ArrayList<String>();
Collection<Number> list3 = new ArrayList<Number>();
Collection<Object> list4 = new ArrayList<Object>();
getElement(list1);
getElement(list2);//报错
getElement(list3);
getElement(list4);//报错
getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
Iterator迭代器
通用的迭代元素的方法，实际上是指针在移动。可以使用增强for循环。增强for只能遍历collection和数组。
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<>(); // 多态
coll.add("张三");
coll.add("李四");
coll.add("老王");
/*Iterator<String> it = coll.iterator(); // 多态
while (it.hasNext()) {
System.out.println(it.next());
}*/
// 增强for训练
for (String s : coll) {
System.out.println(s);
}
}
}
JVM内存划分：
| 区域名称 | 作用域 |
|---|---|
| 寄存器 | CPU使用，和我们无关 |
| 本地方法栈 | JVM在使用操作系统的功能时使用，和我们无关 |
| 方法区 | 存储可以运行的class文件 |
| 堆内存 | 存储对象或者数组，new创建的都存在这里 |
| 方法栈 | 函数、变量等 |