java数据类型

---

基础数据类型

不同于python，Java作为一门面向对象的编程语言，并非所有数据类型都是对象，为了兼容cpp，java也依旧提供基本数据类型，存储在栈中.

1. int，基础整形
2. float，单精度浮点型
3. double，双精度浮点型
4. char，字符型
5. boolean，布尔型
6. long，长整型
7. short，短整型

// 使用
int a = 1;

short b = 2;

long c = 3;

float d1 = 3; // 低精度可向高精度隐式转换
float d = 4.5f; // 高精度不可向低精度隐式转换，如果直接赋值4.5会认定为double类型赋值float而报错

double e1 = 5.88;
double e2 = 1/2; // e2将得到值0.0，理解为double = double(int/int) ，内部先计算得到0再转为double类型
double e3 = 1.0/2; // e3将得到0.5，理解为double  = double/int，不同类型运算同一转为高精度类型
double e4 = double(1)/2; // e4将得到0.5，显示类型转换，原理同上

char f = 'c'; // java中的char是unicode编码

boolean g = true;

---

引用数据类型（对象）

Java中没有指针的概念，引用数据类型可以理解为cpp中指针类型的封装和限制${}^{[1]}$，存储在堆中，同时，Java虚拟机还提供了垃圾回收机制，即所有声明的对象无需手动释放，虚拟机会在适当的时候自动回收.

注[1]：对于 “ java中没有指针，只有对象 ” 的说法，如果是对cpp有所了解，则可能会产生误解，认为java中的对象更接近于cpp中直接声明在栈中的对象。实际上，对于Java所有的引用类型而言，其变量本身都仅仅只是其指向数据空间的管理者，而非所有者，数据空间在堆中开辟，同时，当直接为一个引用类型赋值为另一个引用类型时，并不会开辟一个新空间去拷贝原有对象的内容，而是被赋值的变量同赋值变量一起去管理同一数据空间，显然，这与cpp中的指针更为接近。所以比起认为 “ Java中没有指针，只有对象 ” ，不妨改为 “ Java中没有直接的对象，只有经过封装、限制以及伪装后的指针 ”。

String

字符串，用于存放常规的字符文字信息

// 声明
String str1 = "this is a piece of sentence.";
String str2 = new String("this is a piece of string.");
String str3 = null;

// 使用
str1.length(); // 获取字符串长度
System.out.println(str1); // 输出字符串到屏幕

int[], double[]…

各种类型的静态数组，长度固定，.length可获取其长度

// 声明
int[] arr1 = {1,2,3,4,5};
int[] arr2 = new int[5];
int[] arr3 = null;

// 使用
int size = arr1.length; // 获取数组长度
arr1[0] = 100; // 将第一个元素修改为100

ArrayList

工具库中提供的可变数组，长度可变，同时相较于基本数组提供了各种可供调用的方法，需要引入java.util.ArrayList

import java.util.ArrayList;
// ...
// 声明
ArrayList<String> al1 = new ArrayList<String>();
ArrayList<String> al3 = null;

// 使用
al1.add("first"); // 追加元素"first"
al1.add("second");
al1.add("third");

al1.remove("first"); // 移除元素"first"

System.out.println(al1); // 输出可变列表到屏幕，实际调用toString方法

al1.contains("second"); // 判断数组是否包含元素"second"

ArrayList<String> al2 = al1; // 使al2与al1指向同一数据空间
al3 = new ArrayList<>(al1); // 赋值al1中所有元素给新的数组

System.out.println(al3.get(0)); // 获取索引位的元素并输出

System.out.println(al3.indexOf("third")); // 获取元素所在的下标索引

al3.set(0, "begin"); // 将0号索引的元素值设置为"begin"

al3.set(al3.indexOf("third"), "end"); // 将值为"third"的元素设置为"end"

HashMap

映射类型，也即是键值对的集合，一个键对应唯一的一个值，需要引入java.util.HashMap

import java.util.HashMap;
// ...
// 声明
HashMap<String,String> hm1 = new HashMap<String,String>();
HashMap<String,String> hm3 = null;

// 使用
HashMap<String, String> hm = new HashMap<String, String>();

hm.put("first", "this"); // .put(), 追加键值对到映射
hm.put("second", "that");
hm.put("third", "void");

System.out.println(hm); // 直接输出映射

String info = hm.get("first"); // .get(), 通过键获取对应的值
System.out.println(info);

hm.remove("first"); // 通过键删除键值对

System.out.println(hm.size()); // .size(), 获取映射中键值对的个数

hm.clear(); // .clear(), 清空映射
   
System.out.println(hm.isEmpty()); // .isEmpty(), 判断映射是否为空

System.out.println(hm.keySet()); // 获取由所有的键组成的可迭代集合
System.out.println(hm.values()); // 获取由所有的值组成的可迭代集合
for(String eachKey : hm.keySet()){ // 迭代所有键
System.out.println(eachKey + "," + hm.get(eachKey)); // 输出键，以及通过键得到的值
}

HashSet

可变集合，重复元素将被忽略，需要引入java.util.HashSet

// ...
// 声明
import java.util.HashSet;
HashSet<Integer> hs1 = new HashSet<Integer>();
HashSet<Integer> hs2 = new HashSet<>();
HashSet<Integer> hs3 = null;

// 使用
HashSet<Integer> hs = new HashSet<Integer>();
   
hs.add(3); // 增加元素到集合，并非追加，集合会根据大小自动确定其插入位置
hs.add(3); // 重复添加的元素将被忽略
hs.add(2);
hs.add(4);

System.out.println(hs); // 输出集合本身

hs.remove(3); // 根据值删除元素

System.out.println(hs.size()); // 获取集合元素个数

hs.clear(); // 清空集合

System.out.println(hs.isEmpty()); // 判断集合是否为空

System.out.println(hs.contains(3)); // 判断集合中是否包含元素
   

null

如果将引用类型类比cpp中的指针，那么java中的null即为cpp中的nullptr，当任何引用类型赋值为null，则表示该对象指向为空，并不管理任何实际数据空间。

// 使用
String s = null;
Integer i = null; // 注意int i = null;不合法，即基础数据类型不能赋值为null
Double d = null;

---

包裹类

包裹类也是引用类型的一种，是java中对于基础数据类型的封装，包裹类一般不直接使用，而是用于类中。包裹类型将一个基本数据类型的数据转换成对象的形式，从而使得它们可以像对象一样参与运算和传递。

1. Integer
2. Float
3. Double
4. Character
5. Boolean
6. Long
7. Short
8. Float