JAVA程序设计基础-第6版陈国君2006-学习笔记1

JAVA程序设计基础-第6版陈国君2006-学习笔记1

[TOC]

JAVA程序设计基础-第6版陈国君2006-学习笔记1

书本1-5章内容,介绍程序设计基础。

第一章 Java语言概述

Java语言的诞生与发展

Java语言的特点

  • 简单易学
    抛弃C++中指针(pointer)、联合体(unions)、结构体(structs)
  • 面向对象
    继承、封装、多态
  • 平台无关性
    依靠虚拟机JVM在目标代码级实现平台无关性
  • 分布式
    数据分组和操作分布
  • 可靠性
  • 安全性
  • 支持多线程
  • 支持网络编程
  • 编译与解释并存

Java语言规范

API:应用程序接口(Application Program Interface,API)
Java SE:Java平台标准版(Java Platfrom Standard Edition)
Java ME:Java平台精简版(Java Platfrom Micro Edition)
Java EE:Java平台企业版(Java Platfrom Enterprise Edition)

Java虚拟机

.java文件==》编译器—>.class字节码文件==》解释器

编译(compile)和解释(interpret)

通过编译器(compiler),Java程序会被转换为与平台无关(platform-independent)的机器码

字节码是Java虚拟机(Java Virtual Machine,JVM)的指令组

Java程序的种类和结构

应用程序(Application)

从命令行运行的程序,它可以在Java平台上独立运行。

小程序(Applet)

嵌在HTML(超文本标记语言)文档中的Java程序。

小程序主类继承自系统类JApplet

Java语言结构

  • package语句(0个或1个)
  • import语句(0个或多个)
  • 类定义(1个或多个)

本章小结

  • Java 程序比较特殊,它必经过编译的过程,然后再利用解释的方式来执行。即首先要将源程序(.java 文件)通过编译器将其转换成与平台无关的字节码文件(.class文件),然后再通过解释器来解释执行字节码文件。
  • 字节码(byte codles)最大的好处是可跨平台执行,可让程序”编写一次,到处运行(Write once, run anywhere)”的梦想成真。
  • Java 程序可分为两种:一种是 Application,称为 Java 应用程序;另一种是 Applet,称为Java 小程序。Java 应用程序是指可以在 Java 平台上独立运行的一种程序;而 Java 小程序则是内嵌在 HTML文件里,需要在浏览器的支持下才能运行。
  • 无论是应用程序还是小程序都必须有一个主类,主类是程序执行的人口点,应用程序的主类是包含有main()方法的类,但应用程序的主类并不一定要求是 public 类;小程序的主类是一个继承自系统类 JApplet 的子类,且该类必须是 public 类。

课后习题

  • Java 语言有哪些特点?

简单易学、面向对象、平台无关性、分布式、可靠性、安全性、支持多线程、支持网络编程、编译与解释并存

  • 什么是Java 虚拟机?

可以运行Java字节码的假想计算机,JVM实际上是一个字节码解释器。

  • 什么是字节码?采用字节码的最大好处是什么?

字节码是JVM的指令组,和CPU上微指令码相似。

Java程序编译成字节码后文件尺寸较小,便于网络传输。
字节码可以跨平台运行。

  • 什么是平台无关性?Java语言是怎样实现平台无关性的?

字节码无论使用那种操作系统,都可以在含有JVM的平台上运行。

Java语言源码为.java文件,通过编译器编译后,Java程序会被转换成与平台无关的机器码(字节码)class文件。

  • Java 语言程序有几种?每种程序的结构包含哪几个方面?

两种,应用程序和小程序。

package语句、import语句、类定义

  • 什么是Java程序的主类?应用程序与小程序的主类有何不同?

一个程序中可以有多个类,但是只能有一个类是主类。在Java应用程序中,这个主类是指包含main()方法的类。主类是Java程序执行的入口点。

在Java小程序里,这个主类是一个继承自系统类JApplet的子类。
应用程序的主类不一定要求是public类,但小程序的主类一定要求是public类。

第二章 JAVA语言开发环境

Java开发工具

JDK,Java开发工具(Java SE Development Kits)
JRE,Java运行环境(Java Runtime Environment)
JDK由Java API、Java运行环境和一组建立、测试工具的Java实用程序等组成
API(Application Programming Interface),Java API包括一些重要的语言结构以及基本图形、网络和文件I/O等。

  • JDK的bin目录:

javac.exe:Java编译器,将Java源代码文件转换成字节码文件;
java.exe:Java解释器,执行Java程序的字节码文件;
appletviewer.exe:小程序浏览器,执行嵌入在HTML文件中的Java小程序的Java浏览器;
javadoc.exe:根据Java源代码及注释语句生成Java程序的HTML格式的帮助文档;
jdb.exe:Java调试器,可以逐行执行程序、设置断电和检查变量;
jar.exe:创建扩展名为.jar(Java Archive,Java归档)的压缩文件,与Zip压缩文件格式相同;
jmod.exe:创建扩展名为.jmod的压缩文件。

JDK的下载与安装

  • 下载JDK

jdk-10_windows-x64_bin.exe

  • 安装JDK

JDK目录6个

bin:该文件存放javac.exe、java.exe、jmod.exe、jar.exe等命令程序;
conf:该文件夹存放一些可供开发者编辑的Java系统配置文件;
include:该文件夹存放支持本地代码编程与C程序相关的头文件;
jmods:该文件夹存放预编译的Java模块,相当于JDK9之前的.jar文件;
legal:该文件夹存放有关Java每个模块的版权声明和许可协议等;
lib:该文件存放Java类库。

设置JDK

Ptah,设置供操作系统去寻找可执行文件(如.exe、.com、.bat等),对Java而言即Java的安装路径。
ClassPath,JVM执行Java程序时搜索类(.class)文件的路径(类所在的文件夹)的顺序,以最先找到的为准。

JDK帮助文档下载与安装

JDK的使用

源文件名是由操作系统管理的,所以在使用javac命令编译源文件时,文件名是不区分大小写的。

本章小结

  • JDK的帮助文档(Java docs)与Java开发工具(Java Development Kit)JDK同样是编写Java程序的必备工具。他们均可在Oracle公司的网站免费获得。
  • JDK的核心是Java API,所谓API就是指Java所提供的公开发人员使用的标准类库。
  • 在使用Java语言编译与运行程序之前,必须先设置熊环境变量Path,Path环境变量的作用是设置供操作系统去寻找可执行文件的路径的顺序;在Java10中不用设置类路径ClassPath,Java程序完全可以正常编译与运行。
  • Java应用程序源文件的命名规则;首先源文件的扩展名必须是.java;如果源文件中有多个类,则最多只能有一个public类,如果有,那么源文件的名字必须与这个public类的名字相同(文件名字符的大小写可以与public类名的大小写不同);如果源文件没有public类,那么源文件的名字由用户任意命名。但需要注意的是:包含有main()方法的类是应用程序的主类,主类无论是否是public类,但执行时必须输入主类名,即java主类名,因为主类main()方法是程序执行的起始点。
  • mian()在Java应用程序里是一个相当特殊的方法,它一定要声明成public,使得在类的其他地方能调用到它,且main()方法没有返回值,所以在它之前要加上void关键字。
  • System.out 是指标准输出,其后所跟的字符串println是由print与line所组成,其意义是将它后面括号中的内容输出到标准输出设备——显示器上。
  • 由于Java程序是由类所组成的,所以在完整的Java程序里,至少必须有一个类。

课后习题

  • 什么是JDK?什么是JRE?JDK与JRE的关系是什么?

JDK,Java开发工具(Java SE Development Kits)
JRE,Java运行环境(Java Runtime Environment)
JDK = Java API + JRE + 一组建立、测试工具的Java实用程序

  • Java开发工具JDK10安装后,在安装文件夹下生成几个子文件夹?这些子文件夹中包含的内容有哪些?

6个
bin:该文件存放javac.exe、java.exe、jmod.exe、jar.exe等命令程序;
conf:该文件夹存放一些可供开发者编辑的Java系统配置文件;
include:该文件夹存放支持本地代码编程与C程序相关的头文件;
jmods:该文件夹存放预编译的Java模块,相当于JDK9之前的.jar文件;
legal:该文件夹存放有关Java每个模块的版权声明和许可协议等;
lib:该文件存放Java类库。

  • 环境变量Path和ClassPath的作用是什么?如果设置Path环境变量?

Ptah,设置供操作系统去寻找可执行文件(如.exe、.com、.bat等),对Java而言即Java的安装路径。
ClassPath,JVM执行Java程序时搜索类(.class)文件的路径(类所在的文件夹)的顺序,以最先找到的为准。

  • 编写Java程序有哪些注意事项?

1)源文件扩展名必须是.java;
2)如果源文件中有多个类,则最多只能有一个public类,如果有,那么源文件的名字必须与这个public类的名字相同(文件名字符的大小写可以与public类名的大小写不同);
3)如果源文件没有public类,那么源文件的名字由用户任意命名。

  • Java应用程序源文件的命名有什么规定?

  • Java应用程序的主类是什么样的类?

包含有main()方法的类是Java应用程序的主类,主类无论是否是public类,执行程序必须输入主类名。

  • 如何在命令行方式下编译与运行Java应用程序?
1
2
javac hello.java
java hello

第三章 Java语言基础

数据类型

将数据指定给变量,就是将数据存储到对应的内存空间;
调用变量,就是将对应的内存空间中的数据取出来。

计算机语言将数据按其性质进行分类,每一类成为一种数据类型(data type)。数据类型定义了数据的性质、取值范围、存储方式以及对数据所能进行的运算和操作。

Java语言中的数据类型分为两大类:一类是基本数据类型(primitve types),在内存中存放给的是数据值本身;另一类是引用数据类型(reference types),简称引用类型,也称为对象引用,复合数据类型。其在内存中存放的是指向该数据的地址,不是数据值本身,它往往由多个基本数据类型组成。

每种基本数据类型的数据所占内存和大小是固定的,与软硬件环境无关。

基本数据类型:整型、浮点型、逻辑型、字符型
引用数据类型:类、数组、接口

4类8种基本类型,4整型、2浮点型、1布尔型、1字符型

  • 整形:byte,short,int,long
  • 浮点型:float,double
  • 布尔型:boolean
  • 字符型:char

整型

  • 十进制:用多个0~9的数字表示,如123和-100,其首位不能为0。
  • 八进制:以0开头,后跟多个0~7的数字,如0123。
  • 十六进制:以0x或0X开头,后跟多个0~9的数字或a~f的小写字母或A~F的大写字母,a~f或A~F均表示值10~15,如0X123E。

字节型(byte)、短整型(short)、整型(int)、长整型(long)

每种整形的数据都是带符号位的。

类型 数据位 范围
byte(字节型) 8 -128~127,即 $ -2^{7} $ ~ $ 2^{7} -1 $
short(短整型) 16 -32768~32767,即 $ -2^{15} $ ~ $ 2^{15} -1 $
int(整型) 32 -2147483648 ~ 2147483647,即 $ -2^{31} $ ~ $ 2^{31} -1 $
long(长整型) 64 -9223372036854775808 ~ 9223372036854775807,即 $ -2^{63} $ ~ $ 2^{63} -1 $

一个整数隐含为整型(int型)。当要将一个整数强制表示为长整数时,需在后边加字母l或者L。所以若声明long型变量的值超过int型的取值范围时,如果数的后边不加l或L,系统会认是int型出错。

浮点型

Java语言用浮点型表示数学中的实数(浮点数),也就是既有整数部分又有小数部分的数。

  • 浮点数表示方式

标准计数法:由证书部分、小数点和小数部分构成,如3.0,3.1415等。
科学计数法:由十进制证书、小数点、小数和指数部分构成,指数部分由字母E或者e跟上带正负号的整数表示,如123.45可以表示为1.2345E+2。

类型 数据位 范围
float(单精度浮点) 32 负数范围:-3.402823E+38 ~ -1.4E-45
正数范围:1.4E-45 ~ 3.4028235E+38
double(双精度浮点) 64 负数范围:-1.7976931348623157E+308 ~ -4.9E-324
正数范围:4.9E-324 ~ 1.7976931348623157E+308

布尔型(逻辑型)

true
false

字符型

Java语言中的字符采用的是Unicode字符集编码方案,在内存中战2字节,是16位无符号的整数,一共有65536个。Unicode字符是用 \u0000 到 \uFFF 之间的十六进制数值来表示。Unicode字符前128个字符刚好是ASCII表。

总结

  • Java语言的基本数据类型
数据类型 关键字 占用字节数 默认数值 取值范围
布尔型 boolean 1 false true,falses
字节型 byte 1/8位 0 -126~127
短整型 short 2/16位 0 -32768~32767
整型 int 4/32位 0 -2147483648~2147483647
长整型 long 8/64位 0L -9223372036854775808 ~ 92233720368547775807
单精度浮点数 folat 4/32位 0.0F 负数范围:-3.402823E+38 ~ -1.4E-45
正数范围:1.4E-45 ~ 3.4028235E+38
双精度浮点数 double 8/64位 0.0D 负数范围:-1.7976931348623157E+308 ~ -4.9E-324
正数范围:4.9E-324 ~ 1.7976931348623157E+308
字符型 char 2/16位 \u0000 \u0000 ~ \uffff
  • 数值型常量的特殊值代码
数据类型 所在类 最小值代码 最大值代码
byte java.lang.Byte Byte.MIN_VALUE Byte.MAX_VALUE
short java.lang.Short Short.MIN_VALUE Short.MAX_VALUE
int java.lang.Integer Integer.MIN_VALUE Integer.MAX_VALUE
long java.lang.Long Long.MIN_VALUE Long.MAX_VALUE
float java.lang.Float Float.MIN_VALUE Float.MAX_VALUE
double java.lang.Double Double.MIN_VALUE Double.MAX_VALUE

最小负数获取:double min = -Double.MAX_VALUE

关键字与标识符

关键字(keyword)

关键字是Java语言中被赋予特定含义的一些单词,他们再程序中有着不同的用途,因此Java语言不允许用户对关键字赋予其他的含义。

  • Java语言定义的关键字
abstract assert boolean break byte case
catch char class continue defalut do
double else enum extends false final
finally float for if implements import
instanceof int interface long native new
null package private protected public return
short static super switch synchronized this
throw throws transient true try void
volatile while

标识符(identifier)

标识符是用来表示变量名、类名、方法名、数组名和文件名的有效字符序列。
任何一个变量、常量、方法、对象和类都需需要有名字,这些名字就是标识符。

  • 标志符可以由字母、数字和下画线( _ )、美元符号( $ )等组合组成;
  • 标识符必须以字母、下画线或美元符号开头,不能以数字开头。

常量

常量存储的是在程序中不能被修改的固定值,即常量是在程序运行的整个过程中保持其不改变的量。

整型常量

浮点型常量

布尔型常量

字符型常量

  • 转义符
    是一些有特殊含义、很难用一般方式来表达的字符,如回车、换行。
    所有的转义符都用反斜线( \ )开头,后边跟着一个字符来表示某个特定的转义符
转义符 所代表的含义
\f 换页(from feed),走纸到下一页
\b 退格(backspace),后退一格
\n 换行(new line),将光标移到下一行的开始
\r 回车(carriage return),将光标移到当前行的行首,但不移到下一行
\t 横向跳格(tab),将光标移到下一个制表符位置
\ 反斜线字符(backslash),输出一个反斜杠
\’ 单引号字符(single quote),输出一个单引号
\’’ 双引号字符(double quote),输出一个双引号
\uxxxx 1~4位十六进制数(xxxx)所表示的Unicode字符
\ddd 1~3位八进制数(ddd)所表示的Unicode字符,范围为八进制的000~377

字符串常量

字符串常量是用双引号括起的一串若干字符(可以是0个)

常量的声明

常量声明用final关键字,通常写在最前边。

1
2
final int MAX = 10;
final float PI = 3.14f;
  • 使用常量的好处
    增加可读性。从常量名可知常量的含义。
    增强可维护性。若程序中多处使用常量时,当要对它们进行修改时,只需要在声明语句中修改一处即可。

变量

变量在程序运行中是可以改变的,使用变量必须先声明再使用。

变量声明

程序在使用任何变量之前首先应该在该变量和内存单元之间建立联系。

变量四要素:名字、类型、值、作用域。

  • 变量声明格式
1
2
类型 变量名[ = 初值][, 变量名[= 初值] ...];
int i,j,k;
  • 变量初始化
1
int i = 0;

变量的赋值

1
2
3
4
5
6
7
变量名 = 值;

byte b = 55;
//声明xy并为y赋值
int x,y = 8;
char c;
c = '\u0031'

数据类型转换

数值型不同类型数据的转换

自动类型转换

自动类型转换的条件:

  • 转换前的数据类型与转换后的类型兼容
  • 转换后数据类型的表示范围比转换前数据类型的表示范围大

转换优先关系
byte -> short -> char -> int -> long -> float -> double

  • 扩大转换(augmented conversion)

类型转换只限该语句本身,并不会影响原先变量的类型定义,而且通过自动类型的转换,可以保证数据的精确度,它不会因为类型转换而损失数据的内容。
Java会自动将较小的表示范围转换成较大的表示范围后,在做运算。

强制类型转换(显性转换[explicit cast])

1
(欲转换的数据类型) 变量名
  • 缩小转换(narrowing conversion)

将一个大于变量可以表示范围的值赋值给这个变量。

若将一个大于变量可表示

字符串型数据与整型数据相互转换

字符串转换成数值型数据

转换的方法 功能说明
Byte.parseByte(String s) 将数字字符串转换为字节型数据
Short.parseShort(String s) 将数字字符串转换为短整型数据
Integer.parseInteger(String s) 将数字字符串转换为整型数据
Long.parseLong(String s) 将数字字符串转换为长整型数据
Float.parseFloat(String s) 将数字字符串转换为浮点型数据
Double.parseDouble(String s) 将数字字符串转换为双精度型数据
Boolean.parseBoolean(String s) 将数字字符串转换为布尔型数据
1
2
String myNumber = "1234.567"
float myFloat = Float.parseFloat(myNumber);

数值型数据转换为字符串

字符串用“+”号实现链接操作。

1
2
int myInt = 1234;
String myString = "" + myInt;

由键盘输入数据

输入字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
//APP3_3.java
import java.io.*;

public class App3_3 {
public static void main(String[] args) throws IOException {
BufferedReader buf;
String str;
buf = new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入字符串:");
str = buf.readLine();
System.out.println("您输入的字符串是:" + str);
}
}

输入数值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//APP3_4.java
import java.io.*;

public class App3_4 {
public static void main(String[] args) throws IOException {
float num;
String str;
BufferedReader buf;
buf = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入一个数字:");
str = buf.readLine();
num = Float.parseFloat(str);
System.out.println("你输入的数为:" + num);
}
}

输入多个数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//App3_6.java
import java.util.*;

public class App3_6 {
public static void main(String[] args) {
int num1;
double num2;
Scanner reader = new Scanner(System.in);
System.out.println("请输入一个数:");
num1 = reader.nextInt();
System.out.println("请输入二个数:");
num2 = reader.nextDouble();
System.out.println(num1 + "*" + num2 + " = " +((float)num1 * num2));
}
}
  • 利用Scanner类,使用next()和nextLine()方法接受从键盘输入字符串类型数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//App3_7.java
import java.util.*;

public class App3_7 {
public static void main(String[] args) {
String s1, s2;
Scanner reader = new Scanner(System.in);
System.out.println("请输入第一个数据:");
s1 = reader.nextLine();
System.out.print("请输入第二个数据:");
s2 = reader.next();
System.out.println("输入的是" + s1 + "和" + s2);
}
}

next()方法一定要读取到有效字符后才可以结束输入,对输入有效字符前遇到的空格、Tab或Enter等,会自动去掉,只有在输入有效字符之后,next()方法才将其后输入的空格键、Tab键或Enter键视为分隔符或者结束符。
nextLine()的结束符只是Enter键,返回Enter之前所有的字符。

运算符与表达式

  • 按照操作数目来分
  • 一元运算符:++
  • 二元运算符:+>
  • 三元运算符:?:
  • 按照运算功能来分
  • 算术运算符:+-*/%++--
  • 关系运算符:><>=<===!=
  • 逻辑运算符:!&&||&|
  • 位运算符:>><<>>>&|^~
  • 赋值运算符:=+=/=
  • 条件运算符:? :
  • 其他运算符:分量运算符.、下标运算符[]、实例运算符instanceof、内存分配运算符 new、强制类型转换运算符(类型)、方法调用运算符()

算术运算符

二元算术运算符

  • — * / %

如果浮表达式中有一个或者一个以上的双精度操作数,则按双精度运算,结果是双精度浮点数,如37.2%10=7.2。

一元算术运算符

  • +

取原数

  • -

取相反数

  • ++

+1

  • --

-1

++a/—a:操作数先++或—,然后将结果应用于表达式;
a++/a—:操作数参与其他运算,最后进行++或—。
++/—运算符不能用于表达式,智能用于简单变量。

关系运算符

>
>=
>
<=
==
!=

逻辑运算符

运算符 功能 示例 运算规则
& 逻辑与 a & b 两个操作数均为true时,结果才为true
| 逻辑或 a | b 两个操作数均为false时,结果才为false
! 逻辑非(取反) a ! b 将操作数取反
^ 异或 a ^ b 两个操作数同真或者同假时,结果才为false
&& 简洁与 a && b 两个操作数均为true时,结果才为true
|| 简洁或 a || b 两个操作数均为false时,结果才为false

非简洁运算,必须在计算完成运算符左右两个表达式之后,才取结果值;
简洁运算,只需要计算运算符左边的表达式而不计算右边的表达式。

位运算符

位运算符使对操作数以二进制比特位为单位进行的操作和运算

运算符 功能 示例 运算规则
~ 按位取反 ~a 将a按位取反
& 按位与 a&b 将a和b按比特位相与
| 按位或 a | b 将a和b按比特位异或
^ 按位异或 a^b 将a和b按比特位相异或
>> 右移 a>>b 将a各个比特位向右移b位
<< 左移 a<<b 将a各个比特位向左移b位
>>> 0填充右移 a>>>b 将a各个比特位向左移b位,左边的空位一律填0
  • 按位运算

整数、字符型数据操作

  • 移位运算

赋值运算符

赋值运算符

1
2
变量或对象 = 表达式;
a = b = c =8;

扩展赋值运算符

在赋值符”=”前加上其他运算符,即构成扩展赋值运算符。

运算符 功能 示例
+= a+=b a=a+b
-= a-=b a=a-b
*= a*=b a=a*b
/= a/=b a=a/b
%= a%=b a=a%b
&= a&=b a=a&b
|= a|=b a=a|b
^= a^=b a=a^b
>>= a>>=b a=a>>b
<<= a<<=b a=a<<b
>>>= a>>>=b a=a>>>b

条件运算符

1
2
3
4
5
6
表达式1 ? 表达式2 : 表达式3;

int a = 1,b = 2,max;
max = a > b ? a : b;
//输出结果为max=2
System.out.println("max=" + max);

字符串运算符

“+”符号位字符串运算符

1
2
3
4
5
float a = 100.0f;
//系统自动将a转换为字符串
print("The value of a is" + a + "\n");

s1 += a;

表达式及运算符的优先级、结合性

在对一个表达式进行运算时,要按运算符的优先顺序从高向低进行。

一元 > 算术 > 关系/逻辑 > 赋值

运算符 功能 示例
1 . [] () 左→右
2 ++ — ! ~ +(加号) -(负号) instanceof 右→左
3 new(类型) 右→左
4 * / % 左→右
5 + -(二元) 左→右
6 << >> >>> 左→右
7 < > <= >= 左→右
8 == != 左→右
9 & 左→右
10 ^ 左→右
11 | 左→右
12 && 左→右
13 || 左→右
14 ?: 左→右
15 = += -= *= \/= %= <<= >>= >>>= &= ^= = 右→左
1
2
a >= b && c < d || e == f
((a <= b) && (c < d)) || (e == f)

本章小结

  • Java 语言的数据类型可分为基本数据类型和引用数据类型两种。
  • 常量是在程序运行的整个过程中保持其值不政变的量;变量是其值在程序运行中可以改变的量。
  • Java 语言变量的名称可以由英文字母、数字或下面线等组成。但要注意,名称中不能有空格,且第一个字符不能是数字,还有不能是 Java 语言的关键宇。此外,Java 语言的变量名是区分大小写的。
  • 使用变量的原则是”先声明后使用”,即变量在使用前必须先声明。
  • 变量的赋值有以下三种方法:在声明的时候赋值、声明后再赋值、在程序中的任何位置声明并赋值。
  • Java 语言提供了数值类型量的最大值、最小值的代码。最大值的代码是MAX.VALUE,最小值是 MIN_VALUE。如果要使用某个数值类型量的最大值或最小值,只要在这些代码的前面,加上它们所属的类全名即可。
  • 布尔(boolean)类型的变量,只有true(真)和false(假)两种。
  • Unicode(标准码)为每个字符制定了一个唯一的数值,因此在任何的语言、平台、程序都可以放心地使用。
  • 数据类型的转换可分为两种:自动类型转换和强制类型转换。
  • 由键盘输人数据时,Java 语言的输人格式是固定的1其中,对于数据输入方式 1,不管输入的是文字还是数宇,Java 皆视为字符串,因此若是要由键盘输人数值型数据则必须再经过类型转换;付于数据输人方式2,则是使用 Scanner 类的对象调用相应的nextXXX()方法直接读取由键盘输人的相应类型的数据。
  • 表达式是由操作数与运算符所组成的。括号()是用来处理表达式的优先级的,也是 Java 语言的运算符。
  • 当表达式中各数值型操作数的类型不匹配时,有如下处理方法:①占用较少字节的数据类型会转换成占用较多字节的数据类型;②有short 和int 类型,则用int 类型;③字节类型会转换成short 类型;④int 类型转换成 float 类型:⑤若某个操作数的类型为double,则另一个也会转换成 double 类型;⑤布尔型不能转换成其他的类型。
  • Java 语言的运算符是有优先级和结合性的。运算符的优先级决定了表达式中不同运算执行的先后顺序,而结合性决定了并列的多个同级运算符的先后执行顺序。

课后习题

  • java语言定义了哪几种基本数据类型?

4类8种基本类型,4整型、2浮点型、1布尔型、1字符型

  • 整形:byte,short,int,long
  • 浮点型:float,double
  • 布尔型:boolean
  • 字符型:char
  • 表示整数类型数据的关键字有那几个?他们各占用几个字节?

byte(1),short(2),int(4),long(8)

  • 单精度浮点数(float)和双精度浮点数(double)的区别是什么?

double(4字节),双精度浮点数,负数范围:-1.7976931348623157E+308 ~ -4.9E-324,正数范围:4.9E-324 ~ 1.7976931348623157E+308

float(8字节),单精度浮点数,负数范围:-3.402823E+38 ~ -1.4E-45,正数范围:1.4E-45 ~ 3.4028235E+38

  • 字符型常量与字符串常量的主要区别是什么?

字符型常量是用一对单引号括起来的单个字符,如`a`、`9`。
字符串常量是用双引号括起来的一串若干字符。字符串中可以包括转移符,但标志符字符串开始和结束的双引号必须在源代码的同一行上。

  • 简述Java 语言对定义标识符的规定。

标识符是用来表示变量名、类名、方法名、数组名和文件名的有效字符序列。
任何一个变量、常量、方法、对象和类都需需要有名字,这些名字就是标识符。

  • 标志符可以由字母、数字和下画线( _ )、美元符号( $ )等组合组成;
  • 标识符必须以字母、下画线或美元符号开头,不能以数字开头。
  • Java 语言来用何种编码方案?有何特点?

Java语言中的字符采用的是Unicode字符集编码方案,在内存中战2字节,是16位无符号的整数,一共有65536个。Unicode字符是用”\u0000”到”\uFFF”之间的十六进制数值来表示。Unicode字符前128个字符刚好是ASCII表。

  • 什么是强制类型转换?在什么情況下需要用强制类型转换?

将较长的数据转为较短的数据。
若将一个大于变量可表示范围的值赋值给这个变量时,这种转换称为缩小变换。由于缩小转换在转换过程中可能会因此损失数据的精度,需要做强制类型转换。

  • 自动类型转换的前提是什么?转换时从”短”到”长”的优光级顺序是怎样的?

转换前后数据类型兼容,转换后数据类型表示范围比转换前大。
byte->short->char->int->long->float->double

  • 数字字符串转换为数值型数据时,所使用的方法有哪些?
1
Int a = Integer.parseInt(String s);
  • 写出由键盘输入数据的两种基本格式。
1
2
3
4
5
6
7
8
9
import java.io.*;
String str;
BufferedReader buf;
buf = new BufferedReader(new InputStreamReader(System.in));
str = buf.readLine();

Scanner reader = new Scanner(System.in);
double num;
num = reder.nextDouble();
  • 编写程序,从键盘上输入一个浮点数,然后將该浮点数的整数部分输出。
1
2
3
4
5
6
7
8
9
10
11
12
13
import java.io.*;
import java.util.*;

public class D_3_1 {
public static void main(String[] args) throws IOException {
System.out.println("程序功能:编写程序,从键盘上输入一个浮点数,然后將该浮点数的整数部分输出。");
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个浮点数:");
float num = 0f;
num = sc.nextFloat();
System.out.println("你输入的浮点数是:" + num + "整数部分为:" + (int)num);
}
}
  • 编写程序,从键盘上输入两个整数,然后计算它们相除后得到的结果并输出。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.io.*;
import java.util.*;

public class D_3_2 {
public static void main(String[] args) throws IOException{
System.out.println("程序功能:从键盘上输入两个整数,然后计算它们相除后得到的结果并输出。");
int a, b;
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个整数:");
a = sc.nextInt();
System.out.println("请输入第二个整数:");
b = sc.nextInt();
System.out.println(a + " \\ " + b + " = " + (float)a/b);
}
}
  • 编写程序,从键盘上输入圆柱体的底半径r和高h,然后计算其体积并输。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.io.*;
import java.util.*;

public class D_3_3 {
public static void main(String[] args) throws IOException{
System.out.println("程序功能:从键盘上输入圆柱体的底半径r和高h,然后计算其体积并输。");
float r, h;
Scanner sc = new Scanner(System.in);
System.out.println("请输入圆柱体底半径r:");
r = sc.nextFloat();
System.out.println("请输入圆柱体高h:");
h = sc.nextFloat();
System.out.println("半径 r = " + r + ", 高 h = " + h + ", 体积 = " + Math.PI*r*r*h);
}
}
  • Java 语言有哪些算术运算符、关系运算符、逻辑运算符、位运算符和赋值运算符?

算术运算符:+-*/%
关系运算符:>>=<<===!=
逻辑运算符:&|!^&&||
位运算符:~&|^>><<>>>
赋值运算符:+=-=*=/=%=&=|=^=>>=<<=>>>=

  • 逻辑运算符中的逻辑与、逻辑或和简洁与、简洁或的区别是什么?

非简洁运算:必须计算完运算符左右两个表达式之后,才取结果。
简洁运算:只需要计算运算符左边的表达式而不用计算右边的表达式。

  • 逻辑运算符与位运算符的区别是什么?

逻辑运算时操作数与运算结果都是逻辑型量的运算。
位运算符是对操作数以二进制比特位为单位进行的操作和运算。

  • 什么是运算符的优先级和结合性?

在对一个表达式进行运算时,要按运算符的优先顺序从高向低进行。

  • 写出下列表达式的值,设x=3,y=17,yn=true。
1
2
3
4
5
6
7
8
9
10
11
12
public class D_3_4 {
public static void main(String[] args){
int x = 3;
int y = 17;
boolean yn = true;

System.out.println(" = " + );
System.out.println("运行后:");
System.out.println("x = " + x);
System.out.println("y = " + y);
}
}

(1)x + y * x--

54
运行后:
x=2
y=17

(2)- x * y + y

-34

(3)x < y && yn

true

(4)x > y || !yn

false

(5)y != ++ x ? x : y

4

运行后:
x=4
y=17

(6)y++ / --x

8
运行后:
x=2
y=18

第四章 流程控制

流程控制语句就是用来控制程序中个语句执行顺序的语句,是程序中基本缺又非常更关键的部分。

三种基本流程结构:顺序结构、分支结构(选择结构)、循环结构。

语句与复合语句

语句:指示计算机完成某种特定运算及操作的命令,一条语句执行完后再执行另一条语句。

复合语句(语句块):指由一对花括号括起来的若干简单语句。符合语句定义变量的作用域(scope)。

不允许两个嵌套的符合语句内声明同名的变量。

注释(comment)

单行注释

1
//单行注释(comment on one line)

多行注释

1
2
/* 单行或多行注释
(comment on one or more lines) */

文件注释

主要用于描述类、数据和方法。使用JDK提供的javadoc.exe命令生成扩展名为.html的文件。

1
2
/**
*/

顺序结构

分支结构

if条件语句

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
//双路条件选择
if (条件表达式) {
语句序列1;
} else {
语句序列2;
}

//单路条件选择
if (条件表达式) {
语句序列1;
}

//多重条件选择
if (条件表达式) {
语句序列1;
} else if {
语句序列2;
}
.
.
.
} else if {
语句序列n;
}
} else {
语句序列 n+1;
}

条件表达式必须为bolean,不能为0、1。

switch选择语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
switch (表达式) {
case 常量表达式1:
语句序列1;
break;
case 常量表达式2:
语句序列2;
break;
.
.
.
case 常量表达式n:
语句序列n;
break;
default:
语句序列n+1;
}

条件表达式为整型、字符型。同时与各个case常量表达式类型一致。

1
2
3
4
5
6
7
8
9
10
11
12
13
switch (month) {
case 2:
days=28;
break;
case 4:
case 6:
case 9:
case 11:
days=30;
break;
default:
days=31;
}

循环结构

while语句

1
2
3
while (条件表达式) {
循环体
}

先判断表达式的值,若为真,则执行循环体,循环体执行完之后,再转到条件表达式重新计算表达式的值并判断条件表达式的真假;直到当计算出的条件表达式的值为假时,才跳出循环体执行while语句后面的语句,循环终止。

1
2
3
4
5
6
7
开始=>start: 开始
结束=>end: 结束
循环体=>operation: 循环体
条件表达式=>condition: 条件表达式

开始->条件表达式(yes)->循环体->条件表达式
条件表达式(no)->结束
  • 计算斐波那契

Fibonacci序列的通项公式为:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//D4_5.java
public class D4_5 {
public static void main(String[] args) {
final int MAX = 15;
int i = 0, j = 1, k = 1;
while (k <= MAX) {
System.out.print(" " + i + " " + j);
i = i + j;
j = i + j;
k = k + 2;
}
System.out.println();
}
}
  • 判断菲波那切数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//D4_6.java
import java.util.*;
public class D4_6 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int input = sc.nextInt();
int i = 0, j = 1;
while (input > j) {
i = i + j;
j = i + j;
}
if (j == input) {
System.out.println(input + " 是Fibonacci数。");
} else {
System.out.println(input + " 不是Fibonacci数。");
}
}
}

do-while语句

1
2
3
do {
循环体
} while (条件表达式);

无条件执行一遍循环体,再来判断条件表达式的值,若表达式的值为真,则再执行循环体,否则跳出do-while循环,执行下面语句。

1
2
3
4
5
6
7
开始=>start: 开始
结束=>end: 结束
循环体=>operation: 循环体
条件表达式=>condition: 条件表达式

开始->循环体->条件表达式(yes)->循环体
条件表达式(no)->结束
  • 输入一个正整数n,计算1+2+3+…+n结果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//D4_7.java
import java.util.*;
public class D4_7 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个正整数:");
int input = sc.nextInt();

int i = 0, sum = 0;
do {
sum += i;
i++;
} while (i <= input);

System.out.println("1+2+3+...+" + input +"=" + sum);
}
}
  • 辗转相除法求两数最大公约数

假设有不全为0的整数a和b,他们的最大公约数记为gcd(a,b),即同时能整除a和b的公因数中的最大者。按照欧几里得(Euclid)的辗转相除算法,gcd(a,b)具有如下性质:

①gcd(a,b) = gcd(b,a)
②gcd(a,b) = gcd(-a,b)
③gcd(a,0) = | a |
④gcd(a,b) = gcd(b,a % b),0 <= a % b < b

只要反复运行性质④,最终可以得到第二个参数a % b = 0,第一个参数就是最大公约数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//D4_8.java
import java.util.*;
public class D4_8 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();

System.out.print("gcd(" + a + ", " + b + ") = ");

int num = 1;
do {
num = a % b;
a = b;
b = num;
} while (num != 0);

System.out.print(a);
}
}

for语句

1
2
3
for (表达式1; 条件表达式; 表达式2) {
循环体;
}

首先计算表达式1,完成必要初始化工作 ;判断条件表达式的值,若为假,退出循环,若为真,执行循环体,执行完循环体后再返回表达式2,计算并修改循环条件,这样一轮循环就结束了。第二轮循环从计算并判断条件表达式开始,若表达式的值仍未真,则继续循环,否则,跳出整个for语句执行下面的句子。如果三个条件都为孔,表示无限循环,需要在循环体中写另外的语句跳转来终止循环。

1
2
3
4
5
6
7
8
9
开始=>start: 开始
表达式1=>operation: 表达式1
条件表达式=>condition: 条件表达式
循环体=>operation: 循环体
表达式2=>operation: 表达式2
结束=>end: 结束

开始->表达式1->条件表达式(yes)->循环体->表达式2->条件表达式
开始->表达式1->条件表达式(no)->结束

多重循环

二重循环、三重循环

循环中的跳转语句

不支持无条件goto

break

终止某个case
从某一个循环中立即结束

continue

终止当前一轮循环,直接进入下一轮循环

return

本章小结

  • Java 程序都是由语向组成的,语向可以是以分号;结尾的简单语向,也可以是用
    对花括号{}括起来的复合语句。
  • Java语言的注释方式有三种:①以//开始,直到该行结束;②以/** /括起來的文字;③利用 JDK 提供的javadoc.exe命今所生成的扩展名为.htmal的文档注释。
  • Java 语言的流程控制方式是结构化程序设计中规定的三种基本流程结构:顺序结构、分支结构(或称选择结构)、循环结构。
  • 选择结构包括 if、ifelse 和 switch 三种语句,在程序中使用选择结构,就像处在十字路口一样,根据不同的选择,程序的运行会有不同的方向与结果。
  • 需要重复执行某项功能时,循环结构是最好的选择,这时用户可以根据程序的要求或个人的使用习惯,选择使用 Java 语言所提供的 for、while 或 do-while 循环来完成。
  • 在循环里也可以声明变量,但所声明的变量只是局部变量,只要退出循环,这个变量就不存在了。
  • break 语句可以让程序强行跳离 switch 语句或循环语句,然后转去执行 switch 语句或循环语句的下一条语向,如果 break 语向出现在嵌套的循环中的内循环,则break 语句只会跳离内层循环。
  • continue 语句可以让程序强行跳到循环的开始处去执行下一轮循环,当程序运行到continue 语句时,会停止运行本轮循环体中剩余的语向,而转到循环的开始处继续运行。
  • return 语句用来使程序从方法中返回。

课后习题

  • 将学生的学习成绩按不同的分数段分为优、良、中、及和不及格五个等级,从键盘上输入一个0~100的成绩,输出相应的等级。要求用switch语句实现。
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
29
30
31
32
33
34
35
36
37
38
39
40
41
//D_4_1.java

import java.io.*;
import java.util.*;

public class D_4_1 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个成绩:");
float input = 0f;
input = sc.nextFloat();

int score = (int)input/10;

switch(score){
case 0 :
case 1 :
case 2 :
case 3 :
case 4 :
case 5 :
System.out.println("不及格");
break;
case 6 :
System.out.println("及格");
break;
case 7 :
System.out.println("中");
break;
case 8 :
System.out.println("良");
break;
case 9 :
case 10 :
System.out.println("优");
break;
default:
break;
}
}
}
  • 设学生的学习成绩按如下的分数段评定为四个等级:85~100为A;70~84为B;60-69为C;0~50 为D。从键盘上输入一个0~100的成绩,要求用switch语句根据成绩,评定并输出相应的等级。
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//D_4_2.java

import java.io.*;
import java.util.*;

public class D_4_2 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个成绩:");
float input = 0f;
input = sc.nextFloat();

int score = (int)input/10;

switch(score){
case 0 :
case 1 :
case 2 :
case 3 :
case 4 :
case 5 :
System.out.println("D");
break;
case 6 :
System.out.println("C");
break;
case 7 :
System.out.println("B");
break;
case 8 :
if (input/10 <= 8.4) {
System.out.println("B");
} else {
System.out.println("A");
}
break;
case 9 :
case 10 :
System.out.println("A");
break;
default:
break;
}
}
}
  • 编写一个Java 应用程序,从能键盘输入一个1~100之间的整数,然后判断该数是否可以被3整除又可被7整除的数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//D_4_3.java

import java.io.*;
import java.util.*;

public class D_4_3 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个0~100的整数:");
int input = 0;
input = sc.nextInt();

int mod3 = input%3;
int mod7 = input%7;

if (mod3+mod7 == 0) {
System.out.println(input + " 能被3整除又可被7整除。");
} else {
System.out.println(input + " 不能被3整除又可被7整除。");
}
}
}
  • 编写一个Java应用程序,在键盘上输入数n,计算并输出1!+2!+..+n!的结果。
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
//D_4_4.java

import java.io.*;
import java.util.*;

public class D_4_4 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int input = 0;
input = sc.nextInt();

int sum = 0;

for (int i=1; i<=input; i++) {
int total = 1;
for (int j=1; j<=i; j++) {
total *= j;
}
sum += total;
}

System.out.println("1!+2!+..+" + input + "! = " + sum);
}
}
  • 在键盘上输入数n,编程计算
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
//D_4_5.java

import java.io.*;
import java.util.*;

public class D_4_5 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数:");
int input = 0;
input = sc.nextInt();

double sum = 0.0;
int sign = 1;

for (int i=1; i<=input; i++) {
double total = 1.0;
for (int j=1; j<=i; j++) {
total *= j;
}

sum += sign*(1/total);
sign *= -1;
}

System.out.println("1!-1/(2!)+..(-1)^(" + input + "-1)*1/(" + input + "!) = " + sum);
}
}
  • 水仙花数足指其个位、十位和百位三个数字的立方和等于这个三位数本身,求所有的水仙花数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//D_4_6.java

import java.io.*;
import java.util.*;

public class D_4_6 {
public static void main(String[] args) throws IOException {
for (int i=100; i<1000; i++) {
int bai = i/100;
int shi = (i-bai*100)/10;
int ge = i-bai*100-shi*10;

if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
System.out.println(i);
}
}
}
}
  • 从键盘输入一个整数,判断该数是否是完全数。完全数是指其所有因数(包括1但不包括共自身)的和等于该数自身的数。例如,28=1+2+4+7+14 就是一个完全数。
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
//D_4_7.java

import java.io.*;
import java.util.*;

public class D_4_7 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数:");
int input = 0;
input = sc.nextInt();

int sum = 0;

for (int i=1; i<input; i++) {
if (input%i == 0) {
sum += i;
}
}

if (sum == input) {
System.out.println(input + "是完全数。");
} else {
System.out.println(input + "不是完全数。");
}
}
}
  • 计算并输出一个整数各位数字之和。例如,5423的各位数字之和为5+4+2+3。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//D_4_8.java

import java.io.*;
import java.util.*;

public class D_4_8 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数:");
int input = 0;
input = sc.nextInt();

int sum = 0;
for (int i=input; i!=0; i/=10) {
sum += i%10;
}

System.out.println(input + "各位数字之和 = " + sum);
}
}
  • 从键盘上输入一个浮点数,然后将该浮点数的整数部分和小数部分分别输出。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//D_4_9.java

import java.io.*;
import java.util.*;

public class D_4_9 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个浮点数:");
double input = 0d;
input = sc.nextDouble();

int num1 = (int)input;
double num2 = input - (double)num1;

System.out.println(input + "整数部分为:" + num1);
System.out.println(input + "小数部分为:" + num2);
}
}
  • 设有一长为3000m 的绝子,每天減去一半,问需几天时间,绳子的长度会短于 5m?

10天

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//D_4_10.java

import java.io.*;
import java.util.*;

public class D_4_10 {
public static void main(String[] args) throws IOException {
int sum = 1;
for (int i=3000; i>5; i/=2) {
sum ++;
}

System.out.println(sum);
}
}
  • 编程输出如下数字图案:
1
2
3
4
5
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//D_4_11.java

import java.io.*;
import java.util.*;

public class D_4_11 {
public static void main(String[] args) throws IOException {
int a = 1, b = 0;
int m = 1, n = 1;

for (int i=1; i<=5; i++) { //5行
System.out.print((a+=(b++)) + "\t");//单行第一个数字

m = a;

for (int j=5; j>i; j--) {//单行第一个数字外其他数字
System.out.print((m+=(++n)) + "\t");
}

n = i+1;
System.out.println();
}
}
}

第五章 数组与字符串

数组的基本概念

数组是若干个相同数据类型的元素按一定顺序排列的集合

JAVA内存

栈内存:在方法中定义的一些基本类型和对象的引用变量都在方法中。

堆内存:存放由new运算符创建的数组或者对象,在堆中分配的内存,由Java虚拟的垃圾回收期来自动管理。

引用变量实际上保存的是数组或对象在堆内存中的首地址。
null空指针表示该引用不指向任何对象,当堆中的对象不被任何引用,就会被垃圾回收机制回收。

一维数组

一维数组的定义

1
2
3
4
数据类型[] 数组名;	//声明一维数组
数组名 = new 数据类型[个数]; //分配内存给数组

数据类型[] 数组名 = new 数据类型[个数];

数组定义时候并不为数组元素分配内存,但是必须在分配内存后才可以使用。如果声明元素个数就会分配内存供使用。

1
2
3
4
int[] x;	//声明名称为x的int型数组
x = new int[10]; //x数组中包含有10个元素,并为这10个元素分配内存空间

int[] x = new int[10];

数组每个元素默认值:整数0,实数0.0,字符串为”\0”,boolean型为false,引用型为null。

常用方法 功能说明
public static int binarySearch(X[] a, X key) X是任意数据类型。返回key在升序数组a中首次出现的下标,若a中不包含key,则返回负值。
public static void sort(X[] a) X是任意数据类型。对数组a升序排序后仍存放在a中。
public static void sort(X[] a, int formIndex, int toIndex) 对任意类型的数组a中从formIndex到toIndex-1的元素进行升序排序,其结果仍存放在a数组中
public static X[] copyOf(X[] original, int newLength) 截取任意类型数组original中长度为newLength的数组元素复制给调用数组
public static boolean equals(X[] a, X[] a2) 判断同类型的两个数组a和a2中对应元素是否相等,若相等返回true,否则返回false

一维数组元素的访问

1
2
3
数组名[下标]

x.length 代表数组元素个数

一维数组的初始化及应用

1
2
3
数据类型[] 数组名 = {初值0, 初值1, ... , 初值n};

int[] a = {1, 2, 3, 4, 5};

foreach语句与数组

1
2
3
for (type element : array) {
System.out.println(element);
}
1
2
3
4
int[] arr = {1, 2, 3, 4, 5};
for (int element : arr) {
System.out.println(element);
}

多维数组

二维数组

1
2
3
4
5
6
7
数据类型[][] 数组名;
数组名 = new 数据类型[行数][列数];

int[][] a; //声明二维整型数组a
a = new int[3][4]; //分配一块内存空间,3行4列的整型数组

int[][] a = new int[3][4];

Java的二维数组不一定是规则矩形。

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
29
30
31
32
33
int[][] x = new int[n][];	//不规则矩形二维数组

int[][] x;
x = new int[3][];

x[0] = new int[3];
x[1] = new int[2];

x[0][1] = 100;


int[][] x = new int[2][3]; //创建一个2X3形式的二维数组,在内存中为2X3矩形


x.length; //计算数组x的行数
x[0].length; //计算数组x的第1行元素的个数
x[2].length; //计算数组x的第3行元素的个数


int[][] myArray = new int[10][]; //只指定数组的高层维数
int[][] myArray = new int[10][3]; //指定数组的高层维数和低层维数

int[][] myArray = new int[][5]; //错误申请方式
int[][] myArray = new int[][]; //错误申请方式


数据类型[][] 数组名= { {第1行初值},
{第2行初值},
{ ... },
{第n+1行初值}};

int[][] a = { {11, 22, 33, 44},
{66, 77, 88, 99}};

三维以上的多维数组

1
2
int[][][] a;	//三维
int[][][][] a; //四维

字符串

创建之后不会再修改和变动的字符串变量:String
创建之后允许再做修改的字符串变量:StringBuilder

字符串变量的创建

1
2
3
4
5
String 变量名;
变量名 = new String("字符串");

String s; //声明字符串引用变量s,s在栈内存中为null
s = new String("Hello"); //在堆内存中分配空间,将s指向该字符串首地址

如果字符串与其他类型变量进行”+”运算,系统自动将其他类型的数据转换为字符串类型。

1
2
3
String str1 = "Java";
str1 = str1 + "Good";
//str1已经修改了引用类型,虽然指向的内存地址是同一个,但是对象已经不是同一个了。

String类常用方法

常用方法 功能说明
public int length() 返回字符串的长度
public boolean equals(Object anObject) 将给定字符串与当前字符串相比较,若两字符串相等,则返回true,否则返回fasle
public String substring(int beginIndex) 返回字符串中从beginIndex开始到字符串末尾的子串
public String substring(int beginIndex, int endIndex) 返回beginIndex从开始到beginIndex-1的子串
public cahr charAt(int index) 返回index指定位置的字符
public int indexOf(String str) 返回str在字符串中第一次出现的位置
public int compareTo(String anotherString) 若调用该方法的字符串大于参数字符串,返回大于0的值;若相等返回0;若小于参数字符串则返回小于0的值
public String replace(char oldChar,char newChar) 以newChar字符替换字符串中所有oldChar字符
public String trim() 去掉字符串的首尾空格
public String toLowerCase() 将字符串中所有字符都转换为小写字符
public String toUpperCase() 将字符串中所有字符都转换为大写字符

本章小结

  • 数组是由若干个相同类型的变量按一定顺序排列所组成的数据结构,它们用一个共同的名字来表示。数组的元素可以是基本类型或引用类型。数组根据存放元素的复杂程度,分为一维及多维数组。
  • 要使用 Java 语言的数组,必须经过两个步骤:①声明数组;②分配内存给数组。
  • 在Java 语言中要取得数组的长度,即数组元素的个数,可以利用数组的.length属性来完成。
  • 如果想直接在声明时就给数组赋初值,则只要在数组的声明格式后面加上元素的初值即可。
  • Java 语言允许二维数组中每行的元素个数不相同。
  • 在二维数组中,若要想获得整个数组的行数,或者是某行元素的个数时,也可以利用.length 属性来取得。
  • 字符串可以分为两大类:一类是创建之后不会再做修改和变动的字符申变量;另一类是创建之后允许再做修改的字符串变量。
  • 字符串常量与字符常量不同,字符常量是用单引号(‘)括起来的单个字符,而字符串常量是用双引号(“)括起来的字符序列。

课后习题

  • 从键盘输入n个数,输出这些数中大于其平均值的数。
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
29
30
31
32
33
//D_5_1.java

import java.io.*;
import java.util.*;

public class D_5_1 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数n:");
int n = sc.nextInt();

double[] input = new double[n];
double sum = 0;

System.out.println("请输入n个数:");

for (int i=0; i<n; i++) {
input[i] = sc.nextDouble();
sum += input[i];
}

double ave = sum/n;
System.out.println("这n个数的平均数值为:" + ave);

for (int i=0; i<n; i++) {
if (input[i] > ave) {
System.out.print(input[i] + "\t");
}
}

System.out.print("这些数大于平均值。");
}
}
  • 从键盘输入n个数,求这n个数中的最大数与最小数并输出。
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//D_5_2.java

import java.io.*;
import java.util.*;

public class D_5_2 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数n(n>=3):");
int n = sc.nextInt();

double[] input = new double[n];
double sum = 0;

System.out.println("请输入n个数:");

for (int i=0; i<n; i++) {
input[i] = sc.nextDouble();
sum += input[i];
}

double min, max;

if (input[0] >= input[1]) {
min = input[1];
max = input[0];
} else {
min = input[0];
max = input[1];
}

for (int i=2; i<n; i++) {
if (input[i] < min) {
min = input[i];
}

if (input[i] > max) {
max = input[i];
}
}

System.out.println("最大值:" + max + ", 最小值:" + min);
}
}
  • 求一个3阶方阵的对角线上各元素之和。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//D_5_3.java

import java.io.*;
import java.util.*;

public class D_5_3 {
public static void main(String[] args) throws IOException {
int[][] array = { {11, 22, 33},
{44, 55, 66},
{77, 88, 99}};

int sum = 0;

for (int i=0; i<3; i++) {
for (int j=0; j<3; j++) {
if (i == j) {
sum += array[i][j];
}
}
}

System.out.println(sum);
}
}
  • 找出 4×5 矩阵中值最小和最大元素,并分别输出其值及所在的行号和列号。
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//D_5_4.java

import java.io.*;
import java.util.*;

public class D_5_4 {
public static void main(String[] args) throws IOException {
int[][] array = { {11, 22, 33, 44, 55},
{66, 77, 88, 99, 100},
{110, 120, 130, 140, 150},
{160, 170, 180, 190, 200}};

int[] hang = new int[2]; //0存最小值的行,1存最大值的行。
int[] lie = new int[2]; //0存最小值的列,1存最大值的列。

int min, max;

if (array[0][0] >= array[0][1]) {
min = array[0][1];
hang[0] = 0;
lie[0] = 1;

max = array[0][0];
hang[1] = 0;
lie[1] = 0;
} else {
max = array[0][1];
hang[1] = 0;
lie[1] = 1;

min = array[0][0];
hang[0] = 0;
lie[0] = 0;
}

for (int i=0; i<4; i++) {
for (int j=0; j<5; j++) {
if (array[i][j] < min) {
min = array[i][j];
hang[0] = i;
lie[0] = j;
}

if (array[i][j] > max) {
max = array[i][j];
hang[1] = i;
lie[1] = j;
}
}
}

System.out.println("最大值:" + (hang[1]+1) + "行," + (lie[1]+1) + "列:" + max + ", 最小值:" + (hang[0]+1) + "行," + (lie[0]+1) + "列:" + min);
}
}
  • 产生0~100的8个随机整数,并利用冒泡排序法将其升序排序后输出(冒泡排序算法:每次进行相邻两数的比较,若次序不对,则交换两数的次序)。
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
29
30
31
32
33
34
//D_5_5.java

import java.io.*;
import java.util.*;

public class D_5_5 {
public static void main(String[] args) throws IOException {
int[] num = new int[8];
for (int i=0; i<8; i++) {
num[i] = (int)(Math.random()*100);
}

for (int i=0; i<8; i++) {
System.out.print(num[i] + "\t");
}

System.out.println();

for (int i=0; i<8; i++) {
for (int j=i+1; j<8; j++) {
if (num[i] > num[j]) {
int temp = num[i];
num[i] = num[j];
num[j] = temp;
}
}
}

for (int i=0; i<8; i++) {
System.out.print(num[i] + "\t");
}

}
}
  • 有15个红球和 15 个绿球排成一圈,从第1个球开始数,当数到第 13 个球时就拿出此球,然后再从下一个球开始数,当再数到第13个球时又取出此球,如此循环进行,直到仅剩15 个球为止,问怎样排才能使每次取出的球都是红球?
1
2
3
4
5
6
7
8
9
10
//D_5_6.java

import java.io.*;
import java.util.*;

public class D_5_6{
public static void main(String[] args) throws IOException {

}
}
  • 编写Java 应用程序,比较命令行中给出的两个宇符串是否相等,并输出比较的结果。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//D_5_7.java

import java.io.*;
import java.util.*;

public class D_5_7 {
public static void main(String[] args) throws IOException {
String str1, satr2;
Scanner reader = new Scanner(System.in);
System.out.print("Please enter string1: ");
str1 = reader.nextLine();
System.out.print("Please enter string2: ");
str2 = reader.nextLine();
int cmp;
cmp = str1.compareTo(str2);
System.out.println("Result = " + cmp);
}
}
  • 从键盘上输入一个字符串和子串开始的位置与长度,截取该字符串的子串并输出结果。
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
29
30
31
32
33
34
//D_5_8.java

import java.io.*;
import java.util.*;

public class D_5_8{
public static void main(String[] args) throws IOException {
String str;
Scanner reader = new Scanner(System.in);
System.out.print("Please enter string: ");
str = reader.nextLine();

int sLocation, length;
System.out.print("Please enter start location: ");
sLocation = reader.nextInt();
System.out.print("Please enter length: ");
length = reader.nextInt();

while((sLocation + length - 1) > str.length())
{
System.out.print("Error!Retry!\n");
System.out.print("Please enter length: ");
length = reader.nextInt();
}

String sub = "";
int i, n = str.length();

for(i=0; i<n; i++)
sub = str.substring(sLocation-1, sLocation+length-1);

System.out.println("The new string: " + sub);
}
}
  • 从键盘上输入一个字符串和一个字符,从该字符串中删除给定的字符。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//D_5_9.java

import java.io.*;
import java.util.*;

public class D_5_9 {
public static void main(String[] args) throws IOException {
String str;
Scanner reader = new Scanner(System.in);
System.out.print("Please enter string: ");
str = reader.nextLine();

int i, n = str.length();
String ch;

System.out.print("Please enter char: ");
ch = reader.nextLine();
str = str.replace(ch, "");
System.out.println("New string: " + str);
}
}
  • 编程统计用户从键盘输入的字符串中所包含的字母、数宇和其他字符的个数。
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
29
//D_5_10.java

import java.io.*;
import java.util.*;

public class D_5_10 {
public static void main(String[] args) throws IOException {
String str;
Scanner reader = new Scanner(System.in);
System.out.print("Please enter string: ");
str = reader.nextLine();

int i, n = str.length();
int letterCount=0, numCount=0, otherCount=0;

char ch;
for(i=0; i<n; i++)
{
ch = str.charAt(i);
if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z'))
letterCount++;
if(ch>='0'&&ch<='9')
numCount++;
else
otherCount++;
}
System.out.println("Letter="+letterCount+"Number="+numCount+" Others="+(otherCount-letterCount));
}
}
  • 将用户从键盘输入的每行数据都显示输出,直到输入”exit” 字符串,程序运行结束。
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
//D_5_11.java

import java.io.*;
import java.util.*;

public class D_5_11 {
public static void main(String[] args) throws IOException {
String str;
Scanner reader = new Scanner(System.in);
System.out.print("Please enter string: ");
str = reader.nextLine();

String sub = "exit";
int cmp = str.compareTo(sub);

while(cmp!=0)
{
System.out.println("String: " + str);
System.out.print("Please enter string: ");
str = reader.nextLine();
cmp = str.compareTo(sub);
}

System.out.println("End!");
}
}
文章作者: HibisciDai
文章链接: http://hibiscidai.com/2021/12/20/JAVA程序设计基础-第6版陈国君2006-学习笔记1/
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 HibisciDai
支付宝打赏
微信打赏