蓝桥杯JAVA-4.常用数据类型

本文最后更新于：December 14, 2021 pm

积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里，不积小流无以成江海。齐骥一跃，不能十步，驽马十驾，功不在舍。面对悬崖峭壁，一百年也看不出一条裂缝来，但用斧凿，能进一寸进一寸，能进一尺进一尺，不断积累，飞跃必来，突破随之。

目录

本文着重说一下可能会用到的数据类型。

1.基本数据类型

Java的两大数据类型：内置数据类型、引用数据类型。

1.1 内置数据类型

八种基本类型。
六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

1.1.1 byte

  • byte数据类型是8位、有符号的，以二进制补码表示的整数；
  • 最小值是-128（-2^7）；
  • 最大值是127（2^7-1）；
  • 默认值是0；
  • byte类型用在大型数组中节约空间，主要代替整数，因为byte变量占用的空间只有int类型的四分之一；

例子：byte a = 100，byte b = -50。

1.1.2 short

  • short数据类型是16位、有符号的以二进制补码表示的整数
  • 最小值是-32768（-2^15）；
  • 最大值是32767（2^15 - 1）；
  • Short数据类型也可以像byte那样节省空间。一个short变量是int型变量所占空间的二分之一；
  • 默认值是0；

例子：short s = 1000，short r = -20000。

1.1.3 int（常用）

  • int数据类型是32位、有符号的以二进制补码表示的整数；
  • 最小值是-2,147,483,648（-2^31）；
  • 最大值是2,147,483,647（2^31 - 1）；
  • 一般地整型变量默认为int类型；
  • 默认值是0；

例子：int a = 100000, int b = -200000。

1.1.4 long（常用）

  • long数据类型是64位、有符号的以二进制补码表示的整数；
  • 最小值是-9,223,372,036,854,775,808（-2^63）；
  • 最大值是9,223,372,036,854,775,807（2^63 -1）；
  • 这种类型主要使用在需要比较大整数的系统上；
  • 默认值是0L；

例子： long a = 100000L，long b = -200000L。

1.1.5 float

  • float数据类型是单精度、32位、符合IEEE 754标准的浮点数；
  • float在储存大型浮点数组的时候可节省内存空间；
  • 默认值是0.0f；
  • 浮点数不能用来表示精确的值，如货币；

例子：float f1 = 234.5f。

1.1.6 double（常用）

  • double数据类型是双精度、64位、符合IEEE 754标准的浮点数；
  • 浮点数的默认类型为double类型；
  • double类型同样不能表示精确的值，如货币；
  • 默认值是0.0d；

例子：double d1 = 123.4。

1.1.7 boolean

  • boolean数据类型表示一位的信息；
  • 只有两个取值：true和false；
  • 这种类型只作为一种标志来记录true/false情况；
  • 默认值是false；

例子：boolean one = true。

1.1.8 char

  • char类型是一个单一的16位Unicode字符；
  • 最小值是’\u0000’（即为0）；
  • 最大值是’\uffff’（即为65,535）；
  • char数据类型可以储存任何字符；

例子：char letter = ‘A’。

实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

1.char的输入

也可以用String输入后再转换为char数组。

1
2
3
String s = cin.readLine();
char[] ch = new char[100];
ch = s.toCharArray();
1.1 单个字符
1
2
3
4
5
6
7
8
//示例1
Scanner Scin = new Scanner(System.in);
char ch = Scin.next().charAt(0); //qwer
System.out.println(ch); //q

//示例2
char ch = Scin.next().charAt(3); //qwerasdf
System.out.println(ch); //r
1.2 字符数组
1
2
3
4
char[] ch = new char[50];
String s = Scin.next(); //qwer
ch = s.toCharArray();
System.out.println(ch); //qwer
2.输出

就记录一下坑吧。

先看代码：

1
2
3
4
5
6
char[] ch = new char[50];
String s = Scin.next(); //qwerasdf
ch = s.toCharArray();
System.out.println("s = ：" + s); //s = ：qwerasdf
System.out.println("ch = ：" + ch); //ch = ：[C@2b193f2d
System.out.println(ch); //qwerasdf

解释

可以看见，最后两行输出同一个数组，但输出却不一样。这是因为调用的输出方法不一样。

  • System.out.println(“ch = ：” + ch); 的源码：
1
2
3
4
5
6
public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
  • System.out.println(ch); 的源码：
1
2
3
4
5
6
public void println(char x[]) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

可以看见，两次调用的方法是不一样的。这是println方法的重载问题导致的。第一次调用的方法的参数是String类型，第二次调用的方法的参数是char[]数组类型的。这是因为第一次中的 “ch = ：” 把数组转换成了字符串String类型了。

1.2 Java特殊的转义字符

符号 字符含义
\n 换行 (0x0a)
\r 回车 (0x0d)
\f 换页符(0x0c)
\b 退格 (0x08)
\0 空字符（0x0）
\s 字符串
\t 制表符
\“ 双引号
\‘ 单引号
\\ 反斜杠
\ddd 八进制字符 (ddd)
\uxxxx 16进制Unicode字符 (xxxx)

2.基本数据类型与包装类

包装类（Wrapper）

针对八种基本数据类型定义相应的引用类型 — 包装类（封装类）。

基本数据类型包装类
byteByte父类 ：Number
shortShort
intInteger
longLong
floatFloat
doubleDouble
booleanBoolean
charCharacter

基本数据类型转换为包装类

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class NewJavaTest {
    public static void main(String[] args) {
       int i=120;
       Integer ie = new Integer(i);
       System.out.println(ie.toString());
       Integer it = new Integer("12345"); //必须为数字的字符串
      // s = "456789"; 
      //Integer it = new Integer(s);
      //输出 456789
       System.out.println(it.toString());
//       Integer it2 =new Integer("123abc"); //不能加字母，否则运行时会出错
//       System.out.println(it2.toString());
    }

}
//输出
120
12345

其他的类型用法同样的原理。

包装类转换为基本数据类型

实例：

1
2
3
4
5
6
7
8
9
10
public class NewJavaTest {
    public static void main(String[] args) {
        Integer it = new Integer(13);
        int i = it.intValue();
        System.out.println(i+1);
    }

}
//输出
14

基本数据类型、包装类转换成 String

由于基本数据类型与包装类之间可以自动转换，所以这里就把包装类和基本数据类型当成一种来和 String 之间进行转换。

方式一

1
2
3
4
int num = 10;
String str = num + "";
//输出
10

方式二

1
2
3
4
5
6
7
8
9
float fl = 12.3f;
double db = 23.5;
String str = String.valueOf(fl);
String str1 = String.valueOf(db);
System.out.println(str);
System.out.println(str1);
//输出
12.3
23.5

String 转换成基本数据类型、包装类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class NewJavaTest {
    public static void main(String[] args) {
        String str = "234"; //不能写非数字字符
        int num = Integer.parseInt(str);
        System.out.println(num+1);

        String str2 = "true"; //只有写true输出才为true，其他的都为false，写1也为false
        boolean fl = Boolean.parseBoolean(str2);
        System.out.println(fl);
    }

}
//输出
235
true

转换图

自动装箱

JDK 5.0 新特性。
基本数据类型转换成包装类。

可以理解成，小的转换成大的叫装箱。（这里的小、大表示的是谁包含谁）
实例：

1
2
3
4
5
6
7
8
9
10
public class NewJavaTest {
    public static void main(String[] args) {
        int num = 10;
        Integer it = num;
        System.out.println(it);
    }

}
//输出
10

自动拆箱

包装类转换成基本数据类型。

可以理解成，大的转换成小的叫拆箱。（这里的小、大表示的是谁包含谁）

实例：

1
2
3
4
5
6
7
8
9
10
public class NewJavaTest {
    public static void main(String[] args) {
        Integer it = 12;
        int itt = it;
        System.out.println(itt);
    }

}
//输出
12

3.字符串(String)

3.1 String

Java字符串String是不可变对象。字符串操作不改变原字符串内容，而是返回新字符串。

3.1 字符串比较

  1. 两个字符串比较，总是使用equals()方法。== 比较的是两个的地址。
  1. 忽略大小写比较（equalsIgnoreCase()）
1
2
3
String s1="abcdefghijklmnopkrstuvwxyz"
String s2="ABCDEFGHIJKLMNOPKRSTUVWXYZ"
boolean flag=s1.equalsIgnoreCase(s2)

3.2 查找子串

    1. 是否包含子串（contains()）
1
2
3
4
5
6
7
String s = "abcdefghijklmnopkrstuvwxyz";
System.out.println(s.contains("bc"));
System.out.println(s.contains("bd"));

//输出
true
false
    1. 查看子串是否在母串的开始（startsWith()）
1
2
3
4
5
6
7
String s = "abcdefghijklmnopkrstuvwxyz";
System.out.println(s.startsWith("abc"));
System.out.println(s.startsWith("bcd"));

//输出
true
false
    1. 查看子串是否在母串的最后（endsWith()）
1
2
3
4
5
6
7
String s = "abcdefghijklmnopkrstuvwxyz";
System.out.println(s.endsWith("wxy"));
System.out.println(s.endsWith("xyz"));

//输出
false
true
    1. 找子串第一次出现的下标，从下标0开始（indexOf()），没有找到返回-1
1
2
3
4
5
6
7
String s = "abcdabcedaaq";
System.out.println(s.indexOf("bc"));
System.out.println(s.indexOf("fgh"));

//输出
1
-1
    1. 找子串最后一次出现的下标（lastIndexOf()）
1
2
3
4
5
6
7
String s = "abcdbcq";
System.out.println(s.lastIndexOf("bc"));
System.out.println(s.lastIndexOf("fgh"));

//输出
4
-1
    1. 提取子串（substring()）
1
2
3
4
5
6
7
String s = "abbcccdddd";
System.out.println(s.substring(2)); //从下标2开始
System.out.println(s.substring(1,5)); //从下标1到下标5（不包括5），即[1,5)

//输出
bcccdddd
bbcc

3.3 去除首位空白字符

    1. 去除字符串首尾空白字符（trim()）。空白字符包括空格，\t，\r，\n：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
String s = "  fw few ewf we  q qwf ";
System.out.println(s.length());
System.out.println(s);
s = s.trim();
System.out.println(s.length());
System.out.println(s);

//输出
23
  fw few ewf we  q qwf . //！！！并没有点号，只是为了方便看尾部的空格才手动加上的
20
fw few ewf we  q qwf.


"  \tHello\r\n ".trim(); // "Hello"
    1. 移除字符串首尾空白字符（strip()）。它和trim()不同的是，类似中文的空格字符\u3000也会被移除。
1
2
3
"\u3000Hello\u3000".strip(); // "Hello"。
" Hello ".stripLeading(); // "Hello "。移除字符串首部的空白符
" Hello ".stripTrailing(); // " Hello"。移除字符串尾部的空白符

3.4 判断字符串

判断字符串是否为 空（isEmpty()）和空白字符串（isBlank()）

1
2
3
4
"".isEmpty(); // true，因为字符串长度为0
"  ".isEmpty(); // false，因为字符串长度不为0
"  \n".isBlank(); // true，因为只包含空白字符
" Hello ".isBlank(); // false，因为包含非空白字符

3.5 替换

替换子串（replace()），返回一个新字符串。

1
2
3
String s = "abcbabca";
String s1 = s.replace('a','t');//tbcbtbct，所有的字符a都被替换为t
String s1 = s.replace("ab","tttt"); //ttttcbttttca，所有的子串ab都被替换为tttt

正则表达式替换：

1
2
String s = "A,,B;C ,D";
s.replaceAll("[\\,\\;\\s]+", ","); // "A,B,C,D"，把匹配的子串统一替换为","

3.6 分割字符串

split()，其中表达式就是一个正则表达式。返回的是一个字符串数组。

  1. 特殊情况（斜线\）
1
2
3
4
5
6
7
String s = "ab\\cd\\ef\\g\\h";
String[] s1 = s.split("\\\\"); //以 \ 为分割线
System.out.println(s);
int len=s1.length;
     for(int i=0;i<len;++i){
       System.out.println(s1[i]);
   }
  1. 需要加双斜线的：+、*、$、^、
1
2
3
4
5
6
7
8
9
10
11
12
13
String s = "ab+cdef+gh";
String[] s1 = s.split("\\+"); 
String s = "ab*cdef*gh";
String[] s1 = s.split("\\*"); 
String s = "ab$cdef$gh";
String[] s1 = s.split("\\$"); 
String s = "ab^cdef^gh";
String[] s1 = s.split("\\^"); 
//输出
ab
cdef
gh

  1. 其他
1
2
3
4
5
6
String s = "ab,cde,fgh";
String[] s1 = s.split(",");
//输出
ab
cde
fgh
  1. 多个符号作为分隔符，使用多个分隔符则需要借助 | 符号
1
2
String s = "ab,c+de@fgh";
String[] s1 = s.split(",|\\+|@"); //以逗号、加号、@为分隔符，之间用或（|）

3.7 拼接字符串

拼接字符串使用静态方法join()，它用指定的字符串连接字符串数组。返回一个字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
String s = "ab,c+de@fgh";
String[] s1 = s.split(",|\\+|@");
System.out.println(s);
int len=s1.length;
for(int i=0;i<len;++i){
	System.out.println(s1[i]);
}
System.out.println("===============================");
String s3 = String.join("****",s1);
System.out.println(s3);
//输出
ab,c+de@fgh
ab
c
de
fgh
===============================
ab****c****de****fgh

3.8 格式化字符串

详见 《每日一点-JAVA保留小数点位数》

若链接失效，请直接搜索🔍

3.9 类型转换

  1. 其他类型转字符（String.valueOf()），返回一个字符串。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int n = 15;
String nns = Integer.toString(n);
System.out.println(Integer.toString(n));
boolean fl = false;
System.out.println(Boolean.toString(fl)); //false

int a = 2123;
String resu = String.valueOf(a);
System.out.println(resu);
boolean flag = true;
resu = String.valueOf(flag);
System.out.println(resu);
double f = 23.4324;
resu = String.valueOf(f);
System.out.println(resu);
  1. 字符串转其他类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//整数字符串转整数
String s = "123456";
int nn = Integer.valueOf(s);
System.out.println(nn+100); //123556
System.out.println(Integer.valueOf(s));//123456

String sint = "123456";
int resu = Integer.parseInt(sint);
int re = Integer.parseInt(sint,11); //194871 把字符串里的数字当成11进制数，再转换为10进制。
System.out.println(resu); //123456
resu+=10;
System.out.println(resu); //123466

//boolean字符串转布尔值
String sbool = "true";
boolean fresu = Boolean.parseBoolean(sbool);
    if(fresu) {
        System.out.println("YES");
    }
    else {
        System.out.println("NO");
    }
//YES

//浮点数字符串转浮点数
String sdouble = "13.324";
double resu2 = Double.parseDouble(sdouble);
System.out.println(resu2); //13.324

要特别注意，Integer有个getInteger(String)方法，它不是将字符串转换为int，而是把该字符串对应的系统变量转换为Integer。例如：

1
Integer.getInteger("java.version"); // 版本号，11
  1. 将整数格式化为指定进制的字符串
1
2
3
4
5
6
7
8
 System.out.println(Integer.toString(100)); // "100",表示为10进制
 System.out.println(Integer.toString(100, 36)); // "2s",表示为36进制
 System.out.println(Integer.toHexString(100)); // "64",表示为16进制
 System.out.println(Integer.toOctalString(100)); // "144",表示为8进制
 System.out.println(Integer.toBinaryString(100)); // "1100100",表示为2进制

//或者
System.out.println(Integer.toString(100, radix)); // 将100转换为radix进制的字符串

3.10 字符串与char[]相互转化

1
2
char[] cs = "Hello".toCharArray(); // String -> char[]
String s = new String(cs); // char[] -> String

如果修改了char[]数组，String并不会改变。因为通过new String(char[])创建新的String实例时，它并不会直接引用传入的char[]数组，而是会复制一份，所以，修改外部的char[]数组不会影响String实例内部的char[]数组，因为这是两个不同的数组。

4.StringBuffer和StringBuilder

但两者的使用是没有区别的。所以，会用其一即可。但由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

StringBuilder 是一个可变的字符序列。它继承于AbstractStringBuilder，实现了CharSequence接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
StringBuilder strB = new StringBuilder();

//1、append(String str)/append(Char c)：字符串连接
System.out.println("StringBuilder:"+strB.append("ch").append("111").append('c'));
//return "StringBuilder:ch111c"

//2、toString()：返回一个与构建起或缓冲器内容相同的字符串
System.out.println("String:"+strB.toString());
//return "String:ch111c"

//3、appendcodePoint(int cp)：追加一个代码点，并将其转换为一个或两个代码单元并返回this
System.out.println("StringBuilder.appendCodePoint:"+strB.appendCodePoint(2));
//return "StringBuilder.appendCodePoint:ch111c"

//4、setCharAt(int i, char c)：将第 i 个代码单元设置为 c（可以理解为替换）
strB.setCharAt(2, 'd');
System.out.println("StringBuilder.setCharAt:" + strB);
//return "StringBuilder.setCharAt:chd11c"

//5、insert(int offset, String str)/insert(int offset, Char c)：在指定位置之前插入字符(串)
System.out.println("StringBuilder.insertString:"+ strB.insert(2, "LS"));
//return "StringBuilder.insertString:chLSd11c"
System.out.println("StringBuilder.insertChar:"+ strB.insert(2, 'L'));
//return "StringBuilder.insertChar:chLLSd11c"

//6、delete(int startIndex,int endIndex)：删除起始位置（含）到结尾位置（不含）之间的字符串
System.out.println("StringBuilder.delete:"+ strB.delete(2, 4));
//return "StringBuilder.delete:chSd11c"

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
StringBuilder sb = new StringBuilder("tothefor");
System.out.println(sb);
sb.append(".com"); // append(String str)/append(Char c)
System.out.println(sb);
String mid = sb.toString(); // toString()
System.out.println(mid);
sb.insert(1,"www.");//insert(int offset, String str)/insert(int offset, Char c)
System.out.println(sb);
sb.delete(1,5);//delete(int startIndex,int endIndex) [startIndex,endIndex)
System.out.println(sb);
sb.setCharAt(1,'w');//setCharAt(int i, char c)
System.out.println(sb);

sb.appendCodePoint(65); //ASCII码65是大写的A
System.out.println(sb);

//输出
tothefor
tothefor.com
tothefor.com
twww.othefor.com
tothefor.com
twthefor.com
twthefor.comA

4.1 String与StringBuilder相互转化

1
2
3
4
5
String ss = "abcder";
StringBuilder sbs = new StringBuilder(ss); //String转换为StringBuffer
StringBuilder resbs = sbs.reverse();
String news = resbs.toString(); //StringBuffer转换为String
System.out.println(news);

5.区别

  • String：字符串常量，字符串长度不可变。Java中String 是immutable（不可变）的。用于存放字符的数组被声明为final的，因此只能赋值一次，不可再更改。
  • StringBuffer：字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用 StringBuffer，如果想转成 String 类型，可以调用 StringBuffer 的 toString() 方法。Java.lang.StringBuffer 线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。
  • StringBuilder：字符串变量（非线程安全）。在内部 StringBuilder 对象被当作是一个包含字符序列的变长数组。

基本原则：

  • 如果要操作少量的数据用 String ；
  • 单线程操作大量数据用StringBuilder ；
  • 多线程操作大量数据，用StringBuffer。

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

一般情况下，速度从快到慢为 StringBuilder > StringBuffer > String，当然这是相对的，不是绝对的。

6.length() 方法，length 属性和 size() 方法的区别

  • 1、length() 方法是针对字符串来说的，要求一个字符串的长度就要用到它的length()方法；
  • 2、length 属性是针对 Java 中的数组来说的，要求数组的长度可以用其 length 属性；
  • 3、Java 中的 size() 方法是针对泛型集合说的, 如果想看这个泛型有多少个元素, 就调用此方法来查看!