JAVA内置数据结构概述

1. 内存单位的转换
2. JAVA基本数据类型和转换
3. 串，数组，集合
4. 包装类

---

一、内存单位的转换

8bit(位)=1Byte(字节)
1024Byte(字节)=1KB
1024KB=1MB
1024MB=1GB
1024GB=1TB

---

二、JAVA基本数据类型和转换

分类：
Java基本数据类型就8种，其他都是引用型的。
Java四类八种基本数据类型：
第一类：整型 byte short int long
第二类：浮点型 float double
第三类：逻辑型 boolean(它只有两个值可取true false)
第四类：字符型 char

存储位置：
在栈中可以直接分配内存的数据是基本数据类型。
引用数据类型：是数据的引用在栈中，但是他的对象在堆中。

字节：
boolean 布尔型 1/8
byte 字节类型 1
char 字符型 2 一个字符能存储一个中文汉字
short 短整型 2
int 整数类型 4
float 浮点类型（单精度） 4
long 长整形 8
double 双精度类型（双精度） 8

默认：
Java中默认的整数类型是int类型，如果要定义为float型，则要在数值后加上l或L；
默认的浮点型也是双精度浮点，如果要定义为float型，则要在数值后加上f或F。

转换
基本数据类型自动转换
byte->short,char -> int -> long
float -> double
int -> float
long -> double
记住：小可转大，大转小会失去精度！

---

补充数据类型BigDecimal：

BigDecimal aDouble =new BigDecimal(1.22);
System.out.println("construct with a double value: " + aDouble);
BigDecimal aString = new BigDecimal("1.22");
System.out.println("construct with a String value: " + aString);

你认为输出结果会是什么呢？如果你没有认为第一个会输出1.22，那么恭喜你答对了，输出结果如下：
construct with a doublevalue:
1.2199999999999999733546474089962430298328399658203125
construct with a String value: 1.22

BigDecimal a =new BigDecimal("1.22");
System.out.println("construct with a String value: " + a);
BigDecimal b =new BigDecimal("2.22");
a.add(b);
System.out.println("aplus b is : " + a);

我们很容易会认为会输出：
construct with a Stringvalue: 1.22
a plus b is :3.44
但实际上a plus b is : 1.22

---

三、串、数组、集合

串的操作：
Character 是进行单个字符操作
String 字符串常量（不可变，操作后生成新的对象）
StringBuffer 动态字符串变量（线程安全）
StringBuilder 动态字符串变量（非线程安全）
[注]
String常用的方法有：+, charAt, length, subString
String 转换成StringB类可以用,appead, insert, 反之用toString方法
常用正则表达式匹配：

Pattern p = Pattern.compile("[A-z][0-9]+");
Matcher m = p.matcher(s);
ArrayList<String> al = new ArrayList<String>();
while (m.find()) {
    al.add(m.group());
}

数组的操作：
Java数组自身的操作是很少的，需要导入其他的操作包或者类
定义

String[] aArray = new String[5];
String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};

排序和打印

int[] a = { 1, 2, 3, 4 };
Arrays.sort(a);
System.out.println(Arrays.toString(a));

数组变成动态数组

String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
System.out.println(arrayList);
// [a, b, c, d, e]

检查数组是否包含

String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");
System.out.println(b);
// true

连接2个数组

int[] intArray = { 1, 2, 3, 4, 5 };
int[] intArray2 = { 6, 7, 8, 9, 10 };
// Apache Commons Lang library
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

数组变成字符输出

String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
System.out.println(j);
// a, b, c

数组转化成集合

Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
System.out.println(set);
//[d, e, b, c, a]

数组的翻转

int[] intArray = { 1, 2, 3, 4, 5 };
ArrayUtils.reverse(intArray);
System.out.println(Arrays.toString(intArray));
//[5, 4, 3, 2, 1]

数组元素的删除

int[] intArray = { 1, 2, 3, 4, 5 };
int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
System.out.println(Arrays.toString(removed));

---

集合操作：

常用的集合框架类：
Collection：集合（一般不直接用）
List ：可重复，有序
Set：不重复，无序
Map：键值对

ArrayList：效率高
Vector ：效率低
Stack ：后进先出

HashSet：不重复
LinkedHashSet：不重复，链表
TreeSet：不重复，有序

HashMap ：无序
TreeMap ：有序
HashTable：有序

集合框架的操作：
熟练的在串，数组，集合之间的转换是很有必要的。

集合中逆序的使用：

// 自己是回文则返回，自己不是回文则补全回文
public static String getHuiWen(String str) {
    if (isHuiWen(str) == true)
        return str;
    else {
        String goal = "";
        String LeftMax = getMaxSubStringFromLeft(str);
        String strSub = str.substring(LeftMax.length(), str.length());
        String sb = new StringBuilder().append(strSub).reverse().toString();
        goal = sb + str;
        return goal;
    }
}

集合迭代器的使用：

 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");
 for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }
 /*迭代器用于while循环
 Iterator iter = l.iterator();
 while(iter.hasNext()){
  String str = (String) iter.next();
  System.out.println(str);
 }
 */

---

四、包装类
包装类的主要：
Java是面向对象的，但是基本数据类型不是对象，做成对象后才能传递到某一些方法里。

包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类Number的子类，所有的包装类如下：
byte
Byte
boolean
Boolean
short
Short
char
Character
int
Integer
long
Long
float
Float
double
Double

和基本数据类型一样使用：

Integer a = 10;
a = a + 10;
System.out.println(a);

基本类型和包装类转换

int n = 10;
Integer in = new Integer(100);
Integer in1 = new Integer(n);
int m = in.intValue();

数字字符串变成数字

String s = “123”;
int n = Integer.parseInt(s);

给定进制的转换

//将字符串”120”按照十进制转换为int，则结果为120
int n = Integer.parseInt(“120”,10);
//将字符串”12”按照十六进制转换为int，则结果为18
int n = Integer.parseInt(“12”,16);
//将字符串”ff”按照十六进制转换为int，则结果为255
int n = Integer.parseInt(“ff”,16);

数字转化成数字字符

int m = 1000;
String s = Integer.toString(m);
//或者
String s = m + "";