java数据类型

基本数据类型

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的范围。

数组

数组是引用数据类型，数组需要指定长度和存储数据类型。

数组初始化方法：

1. 动态初始化（指定长度）：int[] arr = new int[3]
2. 静态初始化（指定内容）：char[] arr = new char[]{'a', 'b', 'c'}
3. 省略格式的静态初始化：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创建的都存在这里
方法栈	函数、变量等