抱歉，您的浏览器无法访问本站
本页面需要浏览器支持（启用）JavaScript
了解详情 >

数据类型

基本数据类型

整型 （4种）

  • byte (8位)，最高位表示正负，−27-2^7~27−12^7-1

    byte a = 15;

  • short(16位)，−215-2^{15}~215−12^{15}-1

    short a = 567;

  • int(32位)，−231-2^{31}~231−12^{31}-1，默认为int型

    • 10进制：int a = 123;
    • 16进制：int a = 0x4f;
    • 8进制：int a = 0123;

  • long(64位)，−263-2^{63}~263−12^{63}-1

    long a = 678L;

1
2
3
4
5
6
7
8
9
10
11
public class HelloWorld{
  public static void main(String[] args){
      byte b = 1;
      short s = 200;
      int i = 300;
      long l = 400;
 
      /*如果试图给byte类型的变量赋予超出其范围的值，就会产生编译错误*/
      byte b2 = 200; //报错
  }
}
1
2
3
4
5
6
7
8
9
public class HelloWorld {
    public static void main(String[] args) {
        long val = 26L; //以L结尾的字面值表示long型
        int decVal = 26; //默认就是int型
        int hexVal = 0x1a; //16进制
        int oxVal = 032; //8进制
        int binVal = 0b11010; //2进制
    }
}

字符型 （1种）

  • char类型用于存放一个字符，值用单引号 '' 表示 (双引号表示字符串)；
  • 长度和short一样，也是16位的，只能存放一个字符，超过一个字符就会产生编译错误；
  • 中文字符与英文字母一样，都占用2个字节，即16位
1
2
3
4
5
6
7
8
9
10
11
12
public class HelloWorld{
    
  public static void main(String[] args){
      char c = '中';
      char A = 65;  
      
      //char 只能存放一个字符，超过一个字符就会产生编译错误
      char c2 = '中国'; //报错
      char c3 = 'ab'; //报错
 
  }
}

char与short区别：

​ 在java中，char和short都是两个字节的长度。但char表示的是16位无符号整数，表示的范围是0~65535。short表示的是16位有符号整数，范围为-32768～32767。char用来保存一个Unicode编码的字符。char和short之间类型转换需要强转。

浮点型 （2种）

  • float(32位)
  • double(64位)，小数默认都是double类型，因此要声明float类型的数，要在末尾加一个字母f
1
2
3
4
5
6
7
8
9
10
11
12
public class HelloWorld{
     
  public static void main(String[] args){
        
      float f = 54.321;//报错,因为54.321是double型的
      float f2 = 54.321f;
      
      double d1 = 1.234;
      double d2 = 1.2e3 //即1.2*1000
      
  }
}

布尔型（1种）

  • boolen（1位）：用于表示真假，true或 false，注意不能用1或0来代替
1
2
3
4
5
6
7
8
9
10
11
12
13
public class HelloWorld {
 
    public static void main(String[] args) {
 
        boolean b1 = true;
        boolean b2 = false;
 
        // 虽然布尔型真正存放的数据是0(false) 1(true)
        // 但是，不能直接使用0 1 进行赋值
        boolean b3 = 1;
 
    }
}

引用数据类型

引用数据类型存储的是数据存放的地址

类

在Java中，可以创建一个类，再利用类来创建一个新的实例（对象），该实例的类型就是一种引用数据类型

1
2
3
4
5
6
public class Date{
    int year;
    int month;
    int day;
}

1
Date d1 = new Date() //d1为引用数据类型

字符串(String)

String将字符串当作一个整体来处理，不能修改串中的字符元素，可看作一个字符串常量。

如"This is a string.\n"。注意使用双引号。

  • 定义一个String：
1
2
3
4
5
6
String s1 = new String("123abc");

String s2;
s2 = "123abc";

String s3 = "123abc";
  • 连接两个字符串用 +
1
2
3
4
String s1 = "123";
String s2 = "abc";
String s3;
s3 = s1 + s2;

数组

数组是一个固定长度的，包含了相同类型数据的 容器

  • 声明数组（不会创建数组）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class HelloWorld {
    public static void main(String[] args) {
        // 声明一个数组
        int[] a;
    }
}

/*
int[] a; 声明了一个数组变量。
[]表示该变量是一个数组
int 表示数组里的每一个元素都是一个整数
a 是变量名
但是，仅仅是这一句声明，不会创建数组
*/

  • 创建数组

1
2
3
//先声明再创建
int[] a;
a = new int[5]
1
2
//声明的同时，创建一个数组
int[] a = new int[5];

数组名 a是一个引用

  • 初始化数组

    如果数组的类型为int，未初始化时每个元素默认为0

    • 先声明，创建数组，再一个个元素进行赋值
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    int[] a = new int[5]; //声明和创建
        
    //没有赋值，那么就会使用默认值
    //作为int类型的数组，默认值是0
    System.out.println(a[0]);
        
    //进行赋值

    a[0] = 100;
    a[1] = 101;
    a[2] = 103;
    a[3] = 120;
    a[4] = 140;
    • 声明、创建的同时初始化
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class HelloWorld {
        public static void main(String[] args) {
            //写法一： 分配空间同时赋值
            int[] a = new int[]{100,102,444,836,3236};
     
            //写法二： 省略了new int[],效果一样
            int[] b = {100,102,444,836,3236};
             
        }
    }

    注意：初始化的同时不能指定数组长度：

    1
    int[] c = new int[5]{100,102,444,836,3236};

  • 访问数组

1
2
3
a[0]=1;
a[1]=2;
a[2]=3;

  • 数组长度

    .length属性用于访问一个数组的长度

1
System.out.println(a.length)

  • 二维数组

    下面声明、创建并初始化了一个二维数组

1
2
3
4
5
int[][] b = new int[][]{
   {1,2,3},
   {4,5,6},
   {7,8,9}
};

更新于：2024年3月31日

评论