Java核心技术卷1 第一章 学习笔记

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java核心技术卷1 第一章 学习笔记，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含17585字，纯文字阅读大概需要26分钟。

内容图文

3.3 数据类型

Java是一种强类型语言。必须为每一个变量声明一种类型。在java中，一共有8终基本类型。

3.3.1 整形

byte 和 short类型主要用于特定的应用场合，例如：底层的文件处理或者需要控制占用存储空间量的大数组。

• 长整形数值有一个后缀L或者l(如 400000000L)。
• 十六进制数值有一个前缀0x或0X
• 八进制有一个前缀 0
• 从Java7开始，加上前缀0b或者0B就可以写二进制数

3.3.2 浮点类型

double表示这种类型的数值精度是float类型的两倍。

• float：有一个后缀F或f
• double：后缀为D或d，和不加后缀

下面是用于表示溢出和出错的情况的三个特殊的浮点数值：

1. 正无穷大
2. 负无穷大
3. NaN（不是一个数字）

例如，一个正整数除以0的结果为正无穷大。计算0/0或者负数的平方根结果为NaN。

常量Double.POSITIVE_INFINITY、Double.NEGATIVE_INFINITY和Double.NaN分别表示上面三个特殊的值。

? 不能使用if(x == Double.NaN)检测一个特定值是否等于Double.NaN

? 可以使用if(Double.isNaN(x))检测

3.3.3 char类型

char类型的字面量值要用单引号括起来。例如：'A'

char类型原本用于表示单个字符，但是有些Unicode字符可以用一个char值描述，另一些则需要两个char值。

警告：

? // \u00A0 is a newline：会产生一个语法错误，因为读程序时\u00A0会替换为一个换行符。

? // Look inside c:\users：产生一个语法错误，因为\u后面未跟着4个十六进制数。

3.3.4 Unicode和char类型

建议不要再程序中使用char类型，除非确实需要处理UTF-16代码单元。

3.3.5 boolean类型

boolean类型有 true 和 false 两个值。整型值和布尔值之间不能进行相互转换。

3.4 变量

变量名由字母开头并由字母或者数字组成的序列。变量名长度基本没有限制。

提示： 尽管$是一个合法的Java字符，但不要在程序中使用这个字符。它只用在Java编译器或其他工具生成的名字中。

可以在一行中声明多个变量：int i, j;

3.4.1 变量初始化

声明一个变量后，必须用赋值语句对变量进行显示初始化。

int vacationDays;
System.out.println(vacationDays); //错误，没有进行初始化

3.4.2 常量

利用关键字 final 指示常量。关键字 final 表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了。常量名全大写。

public class Test {
    public static void main(String[] args) {
        final double CM_PER_INCH = 2.54; // 常量
        System.out.println(CM_PER_INCH);
    }
}

如果希望常量可以在一个类中的多个方法中使用，通常将这个常量称为类常量。使用关键字static final。

public class Test {
    static final double CM_PER_INCH = 2.54; // 类常量

    public static void main(String[] args) {
        System.out.println(CM_PER_INCH);
        demo();
    }
    public static void demo(){
        System.out.println(CM_PER_INCH);
    }
}

类常量的定义位于方法的外部。如果一个常量被声明为public，那么其他类的方法也可以使用这个常量。

3.5 运算符

当参加 / 运算的两个操作数都是整数时，表示整数除法；否则，表示浮点除法。

整数被0除会产生一个异常，而浮点数被0除将会得到无穷大或NaN结果。

3.5.1 数学函数与常量

Java中没有幂运算，要用Math类的pow方法。
double y = Math.pow(x,a); 将x的a次幂赋值给y，pow方法有两个double类型的参数，其返回结果也为double。

Math.random 方法将返回一个0 到 1之间(包括0、不包括1)的随机浮点数。

3.5.3 强制类型转换

double x = 9.886;
int nx = (int) x;

强制类型转换通过截断小数部分将浮点值转换为整形。

3.5.4 结合赋值和运算符

如果运算符得到一个值，其类型与左侧操作数的类型不同，就会发生强制类型转换。如果x是一个int，则x += 3.5; ，将把x设置为(int)(x + 3.5).

3.5.5 自增与自减运算符

public class Test {
    public static void main(String[] args) {
        int m = 7;
        int n = 7;
        int a = 2 * ++m;  // a = 16, n = 8
        int b = 2 * n++;  // b = 14, n = 8
    }
}

3.5.8 括号与运算符级别

3.5.9 枚举类型

enum Size{SMALL, MEDIUM, LARGE, EXTRA_LARGE};

3.6 字符串

Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义类，叫String。

3.6.1 字串

String类的substring方法可以从一个较大的字符串中提取出一个字串。

String greeting = "hello";
String s = greeting.substring(0, 3); // hel

3.6.3 不可变字符串

String类没有提供用于修改字符串的方法，所有在Java文档中将String类对象称为不可变字符串。

3.6.4 检验字符串是否相等

使用equals方法检验两个字符串是否相等。

使用equalsIgnoreCase方法，不区分大小写

== 运算符检测两个字符串是否指向同一个对象，但是出现相同内容的多个字符串在不同的位置上，结果为false.

3.6.5 空串与Null串

空串 "" 是长度为0的字符串。

3.6.7 String API

• char charAt(int index)

  返回给定位置的字符

  String str = "hello";
  char ch = str.charAt(1);
  System.out.println(ch); // e

• int codePointAt(int index)

  返回给定位置字符的ASCII码值

  String str = "abc";
  int s = str.codePointAt(2);
  System.out.println(s); // 99

• int compareTo(String other)

  字符串比较函数

  String str = "bcd";
  String str2 = "cc";
  int i = str.compareTo(str2);
  System.out.println(i);

  如果字符串 str 小于 str2，返回一个负数

  如果字符串 str 等于 str2，返回0

  如果字符串 str 大于 str2，返回一个正数

• boolean equals(Object other)

  判断字符串是否与other 相等，返回true.

• boolean equalsIgnoreCase(String other)

  判断字符串是否与other相等(忽略大小写)，返回true

• boolean startsWith(String prefix)

  判断字符串是否以 prefix 字符串 开头

  String str = "abcd";
  boolean is = str.startsWith("ab");
  System.out.println(is); // true

• boolean endsWith(String suffix)

  判断字符串是否以 suffix 字符串结尾

  String str = "abcd";
  boolean is = str.endsWith("cd");
  System.out.println(is); // true

• int indexOf(String str)

  String str = "abcdabcd";
  
  int n = str.indexOf('d');
  System.out.println(n); // 3
  
  int k = str.indexOf('e');
  System.out.println(k); // -1

• int indexOf(int cp)

  String str = "abcdabcd";
  int i = str.indexOf("abc", 3);
  System.out.println(i); // 4
  
  i = str.indexOf("abc", 0);
  System.out.println(i); // 0
  
  i = str.indexOf("ddd", 0);
  System.out.println(i); // -1

• int indexOf(int cp)

  String str = "abcdabcdA";
  
  int i = str.indexOf(97);
  System.out.println(i); // 0
  
  i = str.indexOf(65);
  System.out.println(i); // 8
  
  i = str.indexOf(70);
  System.out.println(i); // -1

• int index (int cp, int fromIndex)

  String str = "abcdabcdA";
  
  int i = str.indexOf(97, 1);
  System.out.println(i); // 4
  
  i = str.indexOf(65, 6);
  System.out.println(i); // 8
  
  i = str.indexOf(70, 0);
  System.out.println(i); // -1

  返回与字符串 str 或 ASCII匹配的最后的最后一个字串的开始位置。这个位置从原始串尾端或fromIndex开始计算。

• int length()

  返回字符串的长度

• int codePointCount(int startIndex, int endIndex)

  返回 开始到结束-1 之间字符个数

  String str = "abcdabcdA";
  
  int i = str.codePointCount(0, 5);
  System.out.println(i); // 5

• String replace(CharSequence oldString, CharSequence newString)

  返回一个新字符串。这个字符串用newString 代替原始字符串中的所有 oldString。可以用 String 或 StringBuilder 对象作为CharSequence 参数。

  String str = "abcdabcd";
  
  String str2 = str.replace("abc", "123");
  System.out.println(str2); // 123d123d

• String substring(int beginIndex)

  String str = "abcd123";
  
  String str2 = str.substring(3);
  System.out.println(str2); // d123

• String substring(int beginIndex, int endIndex)

  String str = "abcd123";
  
  String str2 = str.substring(3, 5);
  System.out.println(str2); // d1

  返回一个新的字符串。这个字符串包含原始字符串中从 beginIndex 到串尾或 endIndex-1 的所有字符。

• String toLowerCase()

  String str = "abcd123ABC";
  
  String str2 = str.toLowerCase();
  System.out.println(str2); //abcd123abc

• String toUpperCase()

  String str = "abcd123ABC";
  
  String str2 = str.toUpperCase();
  System.out.println(str2); //ABCD123ABC

  返回一个新的字符串。这个字符串将原始字符串中的大写字母改为小写，或者将原始字符串中的所有小写字母改成大写字母。

• String trim()

  返回一个新的字符串。这个字符串将删除了原始字符串头部和尾部的空格。

  String str = " abcd123ABC ";
  
  String str2 = str.trim();
  System.out.println(str2); //abcd123ABC

• String join(CharSequence delimiter, CharSequence... elements)

  返回一个新字符串，用给定的定界符连接所有元素

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

3.6.9 构建字符串

按键或者来自文件中的单词。采用字符串连接的方式达到此目的的效率比较低。每次连接字符串，都会构建一个新的String 对象，既耗时，又浪费时间。使用 StringBuilder 类就可以避免这个问题的发生。

char ch = 'a';
String str = "bcd";

StringBuilder builder = new StringBuilder();
builder.append(ch);
builder.append(str);
String completedString = builder.toString();

System.out.println(completedString);  // abcd

在JDK5.0中引入StringBuilder 类。这个类的前身是StringBuffer，其效率稍有些低，但允许多线程的方式执行添加或删除字符的操作。如果所有字符串在一个单线程中编辑，则应该用StringBuilder替代它。

StringBuilder API

• StringBuilder()

  构造一个空的字符串构建器

  StringBuilder builder = new StringBuilder();

• int length()

  返回构建器或缓冲器中的字符个数

• StringBuilder append(String str)

  追加一个字符串(追加到末尾)并返回this

• StringBuilder append(char c)

  追加一个代码单元(字符)并返回this

• StringBuilder appendCodePoint(int cp)

  追加一个代码单元，并将其转为一个或两个代码单元并返回this

  char ch = 'a';
  String str = "bcd";
  
  StringBuilder builder = new StringBuilder();
  builder.append(ch);
  builder.append(str);
  builder.append(65);
  builder.appendCodePoint(66);
  
  System.out.println(builder); // abcd65B

• void setCharAt(int i, char c)

  将第 i 个代码单元设置为c

  char ch = 'a';
  String str = "bcd";
  
  StringBuilder builder = new StringBuilder();
  builder.append(ch);
  builder.append(str);
  builder.setCharAt(1, 'e');
  
  System.out.println(builder); // aecd

• StringBuilder insert(int offset, String str)

  在offset位置插入一个字符串并返回this

  char ch = 'a';
  String str = "bcd";
  
  StringBuilder builder = new StringBuilder();
  builder.append(ch);
  builder.append(str);
  System.out.println(builder); // abcd
  
  builder.insert(2, "123");
  System.out.println(builder); // ab123cd

• StringBuilder insert(int offset, Char c)

  在offset位置插入一个代码单元并返回this

  char ch = 'a';
  String str = "bcd";
  
  StringBuilder builder = new StringBuilder();
  builder.append(ch);
  builder.append(str);
  System.out.println(builder); // abcd
  
  builder.insert(2, '1');
  System.out.println(builder); // ab1cd

• String toString()

  返回一个与构建器或缓冲器内容相同的字符串

   char ch = 'a';
   String str = "bcd";
  
  StringBuilder builder = new StringBuilder();
  builder.append(ch);
  builder.append(str);
  System.out.println(builder.toString()); // abcd

• StringBuilder delete(int startIndex, int endIndex)

  删除偏移量从startIndex到 endIndex-1 的代码单元并返回this

  char ch = 'a';
  String str = "bcd";
  
  StringBuilder builder = new StringBuilder();
  builder.append(ch);
  builder.append(str);
  System.out.println(builder.toString()); // abcd
  
  builder.delete(1, 2);
  System.out.println(builder); // acd

3.7 输入输出

3.7.1 读取输入

想要通过控制台进行输入，首先需要构建一个Scanner 对象，并与 “标准输入流” System.in 关联。

Scanner in = new Scanner(System.in);

nextLine 方法将输入一行。

nextInt 读取一个整数

Scanner API

• Scanner(InputStream in)

  用给定的输入流创建一个 Scanner 对象

  Scanner scan = new Scanner(System.in);

• String nextLine()

  读取输入的下一行内容

  Scanner scan = new Scanner(System.in);
  System.out.println(scan.nextLine());
  // 控制台输入 aaa bbb ccc
  // 控制台输出 aaa bbb ccc

• String next()

  读取输入的下一个单词(以空格作为分隔符)

  Scanner scan = new Scanner(System.in);
  System.out.println(scan.next());
  // 控制台输入 aaa bbb ccc
  // 控制台输出 aaa

• int nextInt()

  Scanner scan = new Scanner(System.in);
  System.out.println(scan.nextInt());
  // 控制台输入 123 23
  // 控制台输出 123

• double nextDouble()

  Scanner scan = new Scanner(System.in);
  System.out.println(scan.nextDouble());
  // 控制台输入 123
  // 控制台输出 123.0
  
  // 控制台输入 123.0
  // 控制台输出 123.0

  读取并转换下一个表示整数或浮点数的字符序列

• boolean hasNext()

  检测输入中是否还有其他单词(是否有输入)，如果有为true

• boolean hasNextInt()

• boolean hasNextDouble()

  检测是否还有表示整数或浮点数的下一个字符序列。

3.7.2 格式化输出

`System.out.printf(x)f

用于printf 的转换符：

System.out.printf("%,.2f",10000.0 / 3.0); // 3,333.33

用于printf 的标志：

可以使用静态的String.format方法创建一个格式化的字符串，而不打印输出：

String message = String.format("Hello, %s. Next year, you'll be %d", name, age);

日期和时间的转换符

3.7.3 文件输入与输出

想要对文件进行读取，就需要一个用File对象构造一个Scanner对象

Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");

如果文件名中包含反斜杠符号，则每个反斜杠前再加一个反斜杠: "c:\\mydirectory\\mybfile.txt"

要想写入文件，就需要构造一个PrintWriter对象:

PrintWriter out = new PrintWrite("myfile.txt","UTF-8");

3.8 流程控制

### 3.8.1 块作用域

块(即复合语句)是指由一对大括号括起来的若干条简单的Java语句。

3.8.2 条件语句

if(){
    语句1
}else if(){
    语句2
}else{
    语句3
}

3.8.3 循环

while(){
 ...   
}

do{
    
}while();

3.8.4 确定循环

for(int i = 1; i <= 10; i++){
    ...
}

3.8.5 多重选择：switch语句

switch(..){
    case 1:
        ... 
       break;
    case 2:
        ...
        break;
    default:
        ..
        break;
}

case 标签可以是：

• 类型为char、byte、short或int 的常量表达式
• 枚举常量
• 从JavaSE7 开始，case标签还可以是字符串字面量

当在switch语句中使用枚举常量时，不必在每个标签中指明枚举名，可以由switch的表达式确定。

Size sz = ...;
switch(sz){
    case SMALL: // no need to use Size.SMALL
    ...
    break;
    ...
}

3.8.6 中断控制流程语句

break;

Java 还提供了一种带标签的break 语句，用于跳出多重嵌套的循环语句。

read_data:
while(...){
    ...
    for(...){
        ...
        break read_data;
        ...
    }
}

continue;

3.9 大数值

如果基本的整数和浮点数精度不能够满足需求，那么可以使用java.math包中的：BigInteger 和 BigDecimal。

3.10 数组

数组是一种数据结构，用来存储同一类型值的集合。通过一个整形下标可以访问数组中的每一个值。

声明整形数组a:int[] a;

使用new运算符创建数组:int[] a = new int[100];

创建一个数字数组时，所有元素都初始化为0。boolean数组的元素会初始化为false。对象数组的元素则初始化为一个特殊值null，这表示这些元素(还)未存放任何对象。

java.lang.ArrayIndexOutOfBoundsException：数组越界异常

一旦创建了数组，就不能再改变它的大小。如果经常需要再运行过程中扩展数组的大小，就应该使用另一种数据结构——数组列表(array list)。

3.10.1 for each 循环

for(variable : collection) statement

提示： 打印数组中的所有值可以使用 Arrays 类的 toString 方法。

3.10.2 数组初始化以及匿名数组

int[] smallPrimers = {2, 3, 5}; ：创建数组对象并同时赋予初始值的简化书写形式。

new int[]{1, 2, 3};：初始化匿名内部类

a = new int[]{1, 2, 3}; ：可以在不创建新变量的情况下重新初始化一个数组。

注意： 允许数组长度为0。数组长度为0 与 null 不同。

3.10.3 数组拷贝

允许将一个数组变量拷贝给另一个数组变量。这时，两个变量将引用同一个数组：

int[] a = b;
a[2] = 12; // b[2] = 12

将一个数组的所有值拷贝到一个新的数组中去，使用Arrays类的copyOf方法：

int[] arr = Arrays.copyOf(a, a.length);

第2个参数是新数组的长度。这个方法常用来增加数组的大小：

a = Arrays.copyOf(a, 2 * a.length);

如果数组元素是数值型，那么多余的元素将被赋值为0；如果数组元素是布尔型，则将赋值为false。相反，如果长度小于原始数组的长度，只拷贝最前面的数据元素。

3.10.5 数组序列

可以使用Arrays 类中的sort方法：

int[] a = new int[100];
...
Arrays.sort(a);

这个方法使用了优化的快速排序算法。

Arrays API

• static String toString(type[] a)

  返回包含a中数据元素的字符串，这些数据元素被放在括号内，并用逗号分隔。参数a 类型为：int、long、short、char、byte、boolean、float或double 的数组。

  int[] a = new int[]{1, 3, 5};
  String s = Arrays.toString(a);
  System.out.println(s); // [1, 3, 5]

• static type copyOf(type[] a, int length)

  int[] a = new int[]{1, 3, 5};
  int[] ints = Arrays.copyOf(a, 6);
  for (int anInt : ints) {
      System.out.println(anInt);
      // 1 3 5 0 0 0
  }

• static type copyOfRange(type[] a, int start, int end)

  String[] strs = new String[]{"abc","123","ccc","ddd"};
  String[] strings = Arrays.copyOfRange(strs, 2,6);
  for (String string : strings) {
      // ccc  ddd  null  null
      System.out.print(string +"  ");
  }

  返回与a类型相同的一个数组，其长度为length 或者 end-start,数组元素为a的值。

  参数：

  • a 类型为int、long、short、char、byte、boolean、float 或 double的数组。
  • start 起始下标（包含这个值）
  • end 终止下标（不包含这个值）。这个值可能大于a.length。在这种情况下，结果为0 或 false。
  • length 拷贝的数据元素长度。如果length值大于a.length，结果为0 或 false；否则，数组中只有前面length个数据元素的拷贝值。

• static void sort(type[] a)

  采用优化的快速排序算法对数组进行排序。

  参数：

  • a 类型为int、long、short、char、byte、boolean、float 或 double的数组。

• static int binarySearch(type[] a, type v)

  int[] a = new int[]{1, 3, 5, 7, 9};
  int i = Arrays.binarySearch(a, 5);
  System.out.println(i); // 2

• static int binarySearch(type[] a, int start, int end, type v)

  int[] a = new int[]{1, 3, 5, 7, 9};
  int i = Arrays.binarySearch(a, 1,4,7);
  System.out.println(i); // 3

  采用二分搜索算法查找值v。如果查找成功，则返回相应的下标值；否则，返回一个负数值r。

  参数：

  • a 类型为int、long、short、char、byte、boolean、float 或 double的有序数组。
  • start 起始下标（包含这个值）
  • end 终止下标（不包含这个值）
  • v 同a的数据元素类型相同的值

• static void fill(type[] a, type v)

  将数组的所有数据元素值设置为v。

  参数：

  • a 类型为int、long、short、char、byte、boolean、float 或 double 的数组。
  • v 与a数据元素类型相同的一个值。

  int[] a = new int[]{1, 3, 5, 7, 9};
  Arrays.fill(a, 3);
  String s = Arrays.toString(a);
  System.out.println(s); // [3, 3, 3, 3, 3]

• static boolean equals(type[] a, type[] b)

  如果两个数组大小相同，并且下标相同的元素都对应相等，返回true。

  参数：

  • a、b 类型为int、long、short、char、byte、boolean、float 或 double 的两个数组。

3.10.6 多维数组

声明二维数组：double[][] balances;

与一维数组一样，在调用new 对多维数组进行初始化之前不能使用它。

balances = new double[NYEARS][NRATES];

int[][] a = {{1,2},{3,4}};：声明并初始化

3.10.7 不规则数组

Java实际上没有多维数组，只有一维数组。多维数组被解释为"数组的数组"。

内容总结

以上是互联网集市为您收集整理的Java核心技术卷1 第一章 学习笔记全部内容，希望文章能够帮你解决Java核心技术卷1 第一章 学习笔记所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端