Java基本语法
/**
文档注释（两个星号，可被解析）
这是我的第一个 Java程序
@author rengui
@version v1.0
*/
public class HelloJava{
/*
1.源文件以 .java 结尾
2. 源文件中可以有多个 class 声明的类
3. 类中可以有主方法（即 main() 方法)，其格式是固定的：public static void main(String[] args){}
4. main()方法是程序的入口，方法内是程序的执行部分。
5. 一个源文件中只能有一个声明为 public 的类，同时要求此类的类名与源文件名一致。
6. 每个语句都以 ";" 结束。
7. 执行程序：①编译：java.exe 编译完，生成诸多个 .class 字节码文件。②运行: java.exe
8. 多行注释不能嵌套。
*/
public static void main (String[] args) {
/*
这是程序的输出语句
格式如下：System.out.println();
*/
System.out.println("welcome to ningde!" + "Hello Java");
System.out.println(" " + "*" + " ");
}
}
一、关键字
- 关键字的定义和特点
- 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
- 特点：关键字中所有字母都为
小写
二、标识符：
- Java 对各种 变量、方法、类和借口等要素命名时使用的字符序列称为标识符
- 凡是自己可以起名字的地方都叫标识符。
（一）、定义合法标识符规则：
- 由26个英文字母大小写，0-9 ，_或 $ 组成
- 数字不可以开头。
- 不可以使用关键字和保留字，但能包含关键字和保留字。
- Java中严格区分大小写，长度无限制。
- 标识符不能包含空格。
（二）、 Java中的名称命名规范：（不遵守，也不会报错）
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
（三）、变量
- 定义变量的格式：数据类型 变量名 = 初始化值
- Java中每个变量必须先声明，后使用
- 变量的作用域：一对{ }之间有效
class Hello{
public static void main(String[] args) {
int a = 1;
String b = "asdf";
System.out.println(b);
}
}
/*
变量之间的运算：（不考虑 Boolean。剩下： char byte short int long float double）
1. 自动类型转换
2. 强制类型转换
*/
class TestVeriable{
public static void main(String[] args) {
//自动类型转换:当容量小的数据与容量大的数据类型做运算时，容量小的会自动转换为容量大的数据类型。
//char,byte,short ==>int ==> long ==> float ==> double
//char,byte,short 之间做运算，默认结果为 int 类型
int a = 12;
short b = 2;
int c = a + b;
float d = 12.3F;
float f = c + d;
double g = f + 12.3;
System.out.println(c);
System.out.println(f);
/*强制类型转换：容量大的转换为小的，要使用强制类型转换符：()
强制类型转换存在的问题：导致精度的损失，
*/
long h = 12345L;
int m =(int)h;
System.out.println(m);
//平时常用的字符串，也是一种数据类型：String
String nation = "made in chan";
System.out.println(nation);
//字符串与基本数据类型之间的运算：只能是连接运算： +。得到的结果认为一个字符串。
String str = "Hello";
String str1 = str + m;//Hello12345
System.out.println(str1);
//先有字符串计算，则全为字符串计算。先有数字计算，再有字符串计算，则数字算完后再与字符串计算。
char ch = 'a';
System.out.println(str1 + a + ch);//Hello1234512a
System.out.println(a + ch + str1);//109Hello12345
System.out.println(ch + str1 + a);//aHello1234512
}
}
三、 1.所有数字在计算机底层都以二进制形式存在。
- 计算机以补码的形式保存所有的整数。 正数的原码、反码、补码都相同 负数的补码是其反码加1。
- 原码：直接将一个数值换成二进制数。
- 反码：是对原码按位取反，只是最高位（符号位）确定为1。
- Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位
1.原码(true form)是一种计算机中对数字的二进制定点表示方法。 原码表示法在数值前面增加了一位符号位（即最高位为符号位）： 正数该位为0，负数该位为1（0有两种表示：+0和-0），其余位表示数值的大小。 例如，我们用8位二进制表示一个数，+11的原码为00001011，-11的原码就是10001011
四、
public class Variable {
public static void main(String[] args){
int a = 3; //a 的数据类型是 int，等于 3.
//int 用来表示一个整数，取值范围在 -2^31 ~ 2^31-1。计算出来是 -2147483648 ~ 2147483647
int b = 5;
int c = 7;
/*
int variable;
variable = 999;
等于
int variable = 999;
*/
int x = 1;
int y = a*x + b*x*x + c*x*x*x;
System.out.println(y);
}
}
整数类型 byte占用1个byte。值域-128~127 short占用2个byte。值域-32768~32767 int占用4个byte。值域-2147483648~2147483647.Java中整数缺省是int类型 long占用8个byte。值域-922337203685477808~922337203685477807
浮点（小数）类型 float占用4个byte，有精度，值域复杂+- double精度是float的两倍，占用8个byte，Java中浮点数缺省是double类型
布尔和字符数据类型 boolean占用1个byte，值域是true，false。代表真假 char占用2个byte，值域是所有字符
public class PrimaryTypes {
public static void main(String[] args) {
/*bit 和 byte
一个二进制的位叫做一个bit。
八个二进制的位，组成一个 byte。
*/
/*整数类型
byte占用 1 个byte。值域 -128 ~ 127
short占用 2 个byte。值域 -32768 ~ 32767
int 占用 4 个byte。值域 -2147483648 ~ 2147483647.Java中整数缺省（默认）是 int 类型
long 占用 8 个byte。值域 -9223372036854774808 ~ 9223372036854774807
*/
byte byteVar = 99;
System.out.println(byteVar);
short shortVar = -30000;
System.out.println(shortVar);
int intVar = 300000;
System.out.println(intVar);
long longVar = 99;
long bigLongVar = 9999999999L; //L表示是long类型。一般用大写L,当然小写也可以,不过，小写易于与1混看。
System.out.println(bigLongVar); //sout 加Tab 键可快速输入该语句。
/*浮点（小数）类型
float占用 4 个byte，有精度。值域复杂
double 精度是 float 的两倍，占用 8 个byte。Java中浮点数缺省是 double 类型。
*/
float floatVar = 100.1F; //F表示float类型，大小写都可。
System.out.println(floatVar);
double doubleVar =100.1;
System.out.println(doubleVar);
/*boolean 占用 1 个byte，值域是 true，false。
char 占用 2 个byte，值域是所有字符。
*/
boolean condition = true;
boolean fcondition = false;
System.out.println(condition);
char ch ='A';
System.out.println(ch);
}
}
public class ModCalc {
public static void main(String[] args) {
/*取模运算符：%
1. 用来计算余数
2. 负数也可以被取模
3. 负数也可以取模
4. 小数也可以取模
*/
//int num = 10;
int num = -10;
System.out.println(num % 2);
System.out.println(num % -3);
System.out.println(num % 4);
System.out.println(num % 5);
System.out.println(num % -6);
//int 除以int 还是 int ，不会变成浮点数
int a = 10;
int b = 3;
double c = 3.0;
System.out.println(a / b);
System.out.println(a / c);
/*
布尔运算符：
! 叫做非运算符，not 运算符。!true 是 flase ，!false 是 true。
& 叫做且运算符，and 运算符。true & flase 是flase，true & true 是 true。
&& 叫做且且运算符，andand 运算符。运算结果和 & 一样。常用&&，而不用& 。 &: 不管左边是true还是flase，右端都会进行计算。&&: 当左端为false时，右端不再进行计算。
| 叫做或运算符，or 运算符。true | flase 是 flase，true | true 是 true, false | flase 是 flase。
|| 叫做或或运算符，oror 运算符.运算结果和 | 一样。常用||，而不用| 。|: 当左端为true 时，右端照样做运算。||:当左端为true 时，右端不再进行运算。
*/
byte d = 10;
int e = 10;
System.out.println(d> e);
/*运算符优先级,由上到下逐次降低
算数》比较》布尔》等号
()
!
*,/,%
+,-
>,>=,<,<=
==
!=
&,&&,|,||
=
*/
}
}
public class BitCalc {
public static void main(String[] args) {
/*位运算符不会改变原变量的值
按位运算符不会改变原本的变量的值
位移运算符不会改变原本的变量的值
*/
/*
按位(bit)运算符.一般能不用就不用
按位并（AND）：&
按位或（OR）:|
按位异或（XOR）：^
按位取反：~
*/
int a = 0xF8; //二进制的 1111 1000
int b = 0xF4; //二进制的 1111 0100
int c = 0xFF; //二进制的 1111 1111
System.out.println(a& b);
System.out.println(a | b);
System.out.println(a ^ b);
System.out.println(~c);
/*
位移运算符：
>>：符号位不动，其余位右移，符号位后面正数补0，负数补1，又称带符号右移。
>>>：符号位一起右移，左边补0，又称无符号右移。
<<：左移，右边补0.左移没有带符号位一说，因为符号位在最左侧
*/
int d = 0x400;
System.out.println(d);
System.out.println(d >> 1);
System.out.println(d >> 2);
System.out.println(d << 1);
System.out.println(d >> 2);
int e = -0x400;
System.out.println(e);
System.out.println(e >> 1);
System.out.println(e >> 2);
System.out.println(e << 1);
System.out.println(e << 2);
System.out.println(e >>> 1);
System.out.println(e >>> 2);
int base = 1;
//0001
int is_student_mask = base;
//0010
int is_programmer_mask = base << 1;
//0100
int is_driver_mask = base << 2;
//1000
int is_painter_mask = base << 3;
//二进制是 0101
int data = 5;
//0101 & 0001 = 1
boolean isStudent = (data & is_student_mask) != 0;
System.out.println(isStudent);
//0101 & 0010 = 0
boolean isProgrammer = (data & is_programmer_mask) != 0;
System.out.println(isProgrammer);
//0101 & 0100 = 0100
boolean isDriver = (data & is_driver_mask) != 0;
System.out.println(isDriver);
//0101 & 1000 = 0
boolean isPainter = (data & is_painter_mask) != 0;
System.out.println(isPainter);
}
}
/*
三元运算符： (条件表达式)?表达式1:表达式2;
要求：表达式1与表达式2为同种数据类型。
既是运算符，就一定会有运算的结果，结果的数据类型与表达式1，2的类型一致。
三元运算符在一定程度上可以与if-else 互换。（三元运算符一定可以转换为if-else,反之不成立。）
*/
public class Two {
public static void main(String[] args) {
int i = 10;
int j = 20;
//此时max记录了i与j的较大值
int max = (i > j)? i : j;
//String str = (i > j)? "i大" : "j大";
String str = (i > j)? "i大" : (i == j)? "相等" : "j大";
//互换
if(i >= j){
System.out.println("较大值为： " + i);
}
else {
System.out.println("较大值为： " + j);
}
System.out.println(max);
System.out.println(str);
}
}
class TestConversion{
public static void main(String[] args) {
//手动的方式，从控制台输出 60 的十六进制。
int i = 60;
/*
char c = 'a';
char c1 = (char)(c +2);
System.out.println(c1); //c
*/
int j = i & 15;//获取到i最低四位对应的值。1111为15.
String k1 = (j <= 9)? j + "" : (char)(j - 10 + 'a') + "";//转为字符串类型。
i = i >> 4;
int z = i & 15;
String k2 = (z <= 9)? z + "" : (char)(z -10 + 'a') + "";
System.out.println(k2 +k1);
}
}
//流程控制：顺序结构；分支结构（if-else； switch-case）；循环结构（while； do…while；for(;;))
class TestIf1 {
public static void main(String[] args) {
/*格式三种。执行if-else时，一定选择其中的一个路径执行，
而且也仅会选择一条路径。
*/
int age = 28;
if (age > 18){
System.out.println("你已经是成年人了");
}else{
System.out.println("你还不能看成年电影");
}
if(age > 130 || age < 0){
System.out.println("你估计不是人");
}else if(age < 30){
System.out.println("人家还很年轻，只有" + age + "岁");
}else {
System.out.println("你别追我了，我都有两个娃了");
}
}
}
1.根据变量的值，选择相应的case 去判断，一旦满足 case 条件，就执行case 的相应语句。 如果没有break或者未到程序结尾时，会继续执行其下的case 语句。 2/default 是可选的，而且位置是灵活的 3。变量可以是哪些数据类型：char byte short int 枚举 String 4.case 条件：其中条件只能是值，不能是取值范围
class TestSwitch1{
public static void main(String[] args) {
int i = 1;
switch (i){
case 0:
System.out.println("zero");
case 1:
System.out.println("one");
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
default:
System.out.println("other");
break;
}
}
}
对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
注意：当多个case 语句处理的语句块一致时，可以统一书写。
class TestSwitch3 {
public static void main(String[] args) {
int score = 67;
// if(score >= 60){
// System.out.println("及格");
// }else {
// System.out.println("不及格");
// }
switch (score / 10) {
case 10:
case 9:
case 8:
case 7:
case 6:
System.out.println("及格");
break;
case 5:
case 4:
case 3:
case 2:
case 1:
case 0:
System.out.println("不及格");
break;
default:
System.out.println("输入有误");
break;
}
}
}
流程控制
/*
for 循环结构：
1.格式：
①初始化条件
②循环条件
③迭代条件
④循环体
for(①;②;③){
//④
}
2.执行过程：❶-❷-④-③-②-④-③-②.......-④-③-②
即直至循环条件不满足，退出当前循环。
*/
import java.util.Scanner;
public class Three {
public static void main(String[] args) {
for(int i = 0; i < 4; i++){
System.out.println("Hello World");
}
int j = 1;
for(System.out.print('a'); j < 3; System.out.print('b'), j++){
System.out.print('c');
}//acbcb
//题目：输出 100 以内的所有的偶数及所有偶数的和，偶数的个数。
int sum = 0;
int count = 0;
for (int i = 1; i <= 100; i++){
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++; //执行多少回就有多少个
}
}
System.out.println("总数为：" + sum);
System.out.println("100以内的偶数个数为：" + count);
}
}
编写程序FooBizBaz.java，从1循环到150并在每行打印一个值， 另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”, 在每个7的倍数行上打印输出“baz”。
class FooBizBaz{
public static void main(String[] args) {
for(int i = 1;i <= 150;i++){
System.out.print(i + " "); //println 会换行
if(i % 3 == 0){
System.out.print("foo ");
}
if(i % 5 == 0){
System.out.print("biz ");
}
if(i % 7 == 0){
System.out.print("baz ");
}
System.out.println();//换行
}
}
}
输出所有的水仙花数，所谓水仙花数是指一个3 位数，其各个位上数字立方和等于其本身。 例如： 153 = 111 + 333 + 555
class ShuiXianHua{
public static void main(String[] args) {
for(int i =100;i < 1000; i++){//实现100~999的遍历
int j1 = i / 100;//百位
int j2 = (i - j1*100)/10;//十位 456 - 400 = 56 / 10 = 5
int j3 = i % 10;//个位
if(i == j1*j1*j1 + j2*j2*j2 + j3*j3*j3){
System.out.println(i);
}
}
}
}
while 循环结构： ①初始化条件 ②循环条件 ③迭代条件 ④循环体 1.格式： ① while(②){ ④ ③ }
- for 循环与while循环可以相互转换
class TestWhile{
public static void main(String[] args) {
//100以内的偶数的输出,及其和
int i = 1;
int sum = 0;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
sum +=i;
}
i++;
}
System.out.println("100以内的偶数的和为:" + sum);
}
}
dowhile 循环结构： ①初始化条件 ②循环条件 ③迭代条件 ④循环体 1.格式： ① do{ ④ ③ }while(②);
- do-while 与 while 的区别：do-while循环至少执行一次
class TestDoWhile{
public static void main(String[] args) {
//100以内的偶数的输出
int i = 1;
do{
if(i % 2 == 0){
System.out.println(i);
}
i++;
}while (i <= 100);
}
}
问题一：从键盘读入个数为 10 个的整数，并判断读入的正数和负数的个数， 问题二：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
无限循环： for(;;){} 或者： while(true){ } 说明：一般情况下，在无限循环内部要有程序终止的语句，使用 break 实现。若没有，那就是死循环。
//import java.util.Scanner;
class TestExer{
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int a = 0;//记录正数的个数
int b = 0;//记录负数的个数
//for(;;){
while (true){
System.out.println("请输入一个整数：");
int num = s.nextInt();
if (num > 0)
a++;
else if (num < 0)
b++;
else
break; //输入 0 时终止
}
/*
//问题一
for (int i = 0; i < 10;i++){
System.out.println("请输入第" + (i + 1) + "个正数");
int num = s.nextInt();
if (num > 0)
a++;
else if (num < 0)
b++;
}
*/
System.out.println("正数的个数为：" + a);
System.out.println("负数的个数为：" + b);
}
}
嵌套循环：循环中还可以声明循环。相当于内层循环的整体充当外层循环的循环体。 若外层循环执行 m 次，内层循环执行 n 次，整个程序执行 m*n 次。 for(;;){ for(;;){
} } 或者： while(){
for(;;){
} }
class TestForFor{
/*
*****
*****
*****
*****
*/
public static void main(String[] args) {
for(int j = 0;j < 4;j++){//外层循环控制行数
for(int i = 0;i < 5;i++){//内层循环控制列数
System.out.print("*");
}
System.out.println();
}
// for(int i = 0;i < 5;i++){
// System.out.print("*");
// }
// System.out.println();
// for(int i = 0;i < 5;i++){
// System.out.print("*");
// }
// System.out.println();
// for(int i = 0;i < 5;i++){
// System.out.print("*");
// }
// System.out.println();
/*
*
**
***
****
*/
for(int j = 0;j < 4;j++){//外层循环控制行数
for(int i = 0;i < j + 1;i++){//每行输出 j + 1 个。
System.out.print("*");
}
System.out.println();
}
/*
*****
****
***
**
*
*/
for(int i = 0; i < 5;i++){
for(int j = 0;j < 5 - i;j++) {//for(int j = i; j < 5;j++)
System.out.print("*");
}
System.out.println();
}
/*
----*
---* *
--* * *
-* * * *
* * * * *
i j(-) k(*)
0 4 1
1 3 2
2 2 3
3 1 4
4 0 5
* * * *
* * *
* *
*
*/
//上半部分：
for(int i = 0;i < 5;i++){
//输出“-”
for(int j = 0;j < 4-i;j++){
//System.out.print("-");
System.out.print(" ");
}
//输出“* ”
for(int k = 0;k < i+1;k++){
System.out.print("* ");
}
System.out.println();
}
//下半部分：
for(int i = 0;i < 4;i++){
//输出“-”
for(int j = 0;j < i + 1;j++){
//System.out.print("-");
System.out.print(" ");
}
//输出“* ”
for(int k = 0;k < 4 - i;k++){
System.out.print("* ");
}
System.out.println();
}
}
}
1 * 1 = 1 2 * 1 = 2 2 * 2 = 4 … 9 * 1 = 9 …… 9 * 9 = 81
class TestJiuJiu{
public static void main(String[] args) {
for(int i = 1;i <= 9;i++){//一共有 9 行
for(int j = 1;j <= i;j++){//每行有 i 个等式
System.out.print(i + "*" + j + "=" + i*j + "\t");
}
System.out.println();//换行
}
}
}
100 以内的所有质数 质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。
class TestPrimeNumber{
public static void main(String[] args) {
long start = System.currentTimeMillis();//获取系统当前的毫秒数
boolean flag = false;
for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历
//如何判断i是否为一个质数
//for(int j = 2;j < i;j++){
for(int j = 2;j <= Math.sqrt(i);j++){//根号i
if(i % j == 0){
flag = true;
break;//8 % 2/3/4/5..7出现第三个质数时，直接过滤
}
}
//if(flag == false){
if(!flag){
System.out.println(i);
}
flag = false;//初始化，如果没有初始化，则一旦数据为true，后边数据就不会执行上一步if语句。
}
long end = System.currentTimeMillis();
System.out.println("所花费的时间为：" + (end - start));
}
}
class TestPrimeNumber1{
public static void main(String[] args) {
long start = System.currentTimeMillis();//获取系统当前的毫秒数
l:for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历
//如何判断i是否为一个质数
//for(int j = 2;j < i;j++){
for(int j = 2;j <= Math.sqrt(i);j++){//根号i
if(i % j == 0){
continue l;
}
}
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println("所花费的时间为：" + (end - start));
}
}
break：使用在 switch-case 中或者循环中 如果使用在循环中，表示：结束当前循环
continue:使用在循环结构中 表示：结束当次循环
理解break和continue中标签的使用
在break和continue语句之后不能添加其他语句，因为永远也不会被执行。
class TestBreakContinue{
public static void main(String[] args) {
// for(int i = 1;i <= 10;i++){
// if(i % 4 == 0){
// //break;
// continue;
// }
// System.out.println(i);
// }
// for(int i = 1;i < 5;i++){
label:for(int i = 1;i < 5;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
// break;
// continue
break label;
// continue label;
}
System.out.print(j);
}
System.out.println();
}
}
}
一个数如果恰好等于它的因子之和，这个数就称为”完数”。（因子：除去这个数本身正的约数） 例如6=1＋2＋3.编程 找出1000以内的所有完数
class WanShu {
static int count;
public static void main(String[] args) {
int factor = 0;
for (int i = 1; i <= 1000; i++) {
//每执行完一次如下的循环，就会将i的所有的因子累加到factor中。
for (int j = 1; j < i; j++) {
if(i % j==0)
factor += j;
}
if(factor == i){
System.out.println(i);
count++;
}
factor = 0;
}
System.out.println("1-1000之间的完数个数为：" + count);
}
}
数组：
import java.util.Arrays;
import java.util.Scanner;
public class Four {
public static void main(String[] args) {
boolean b = true;
//1. 如何定义一个数组
//1.1 数组的声明
String[] names;
int[] scores;
//1.2 初始化
//第一种：静态初始化：初始化数组与给数组元素赋值同时进行。
names = new String[]{"春","夏","秋","冬"};
//第二种：动态初始化：初始化数组与给数组元素赋值分开进行。
//不管是动态还是静态初始化数组，一定在创建的时候，就指明了数组的长度。
scores = new int[4];//数组个数/长度
//2.如何调用相应的数组元素：通过数组元素的下角标的方式来调用
//下角标从 0 开始，到 n-1 结束。其中 n 表示数组的长度
scores[0] = 87;
scores[1] = 79;
scores[3] = 97;
//3.数组的长度：通过数组的 length 属性
System.out.println(names.length);//4
System.out.println(scores.length);//4
//4.如何遍历数组元素
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}
}
}
class TestArray{
public static void main(String[] args) {
//对于基于基本数据类型的变量创建的数组：byte short int long float double char boolean
//1.对于 byte short int long 而言，创建数组以后，默认值为 0 .
int[] a = new int[4];
a[0] = 61;
// a[1] = 71;
// a[2] = 81;
a[3] = 91;
//遍历数组的元素
for (int i = 0;i < a.length;i++){
System.out.println(a[i]);
}
System.out.println();
//2.对于 float double 而言，默认值是 0.0 。
float[] b = new float[4];
b[0] = 62.2F;
// a[1] = 72.2F;
// a[2] = 82.2F;
b[3] = 92.2F;
//遍历数组的元素
for (int i = 0;i < b.length;i++){
System.out.println(b[i]);
}
System.out.println();
//3.对于 char 而言，默认为空格。
char[] c = new char[4];
//遍历数组的元素
for (int i = 0;i < c.length;i++){
System.out.println(c[i]);
}
System.out.println();
//4.对于 boolean 而言，默认为 false 。
boolean[] d = new boolean[4];
//遍历数组的元素
for (int i = 0;i < d.length;i++){
System.out.println(d[i]);
}
System.out.println();
//5. 对于引用数据类型的变量构成的数组而言，默认初始化值为 null 。以 String 为例。
String[] strs = new String[4];
strs[0] = "AA";
strs[1] = "BB";
// strs[2] = "CC";
strs[3] = "DD";
//遍历数组的元素
for (int i = 0;i < strs.length;i++){
System.out.println(strs[i]);
}
System.out.println();
//另例，引用自定义类。
Person[] Pers = new Person[4];
for (int i = 0;i < Pers.length;i++){
System.out.println(Pers[i]);
}
}
}
class Person{
}
数组一旦初始化，其长度是不可变的
class TestArray1{
public static void main(String[] args) {
int[] i = new int[]{12,13,14};
int[] j = new int[10]; //定义一个长度长一点的数组
for(int k = 0;k < i.length;k++){
j[k] = i[k];//拷贝过来
}
j[3] = 15;
j[4] = 16;
for(int k = 0;k < j.length;k++){
System.out.println(j[k]);
}
}
}
1.(1)定义类Pritimive，在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。 定义类TestPritimive，在TestPritimive的main()方法中创建Pritimive对象d，输出其成员变量t的三个元素值。 练习目的：检验基本数据类型数组创建时的自动赋值。 (2)给对象d的成员变量t赋值为{true,true,true}，并输出t的三个元素值。
class TestPritimive{
public static void main(String[] args) {
//创建 Pritimive 的对象 d 。
Pritimive d = new Pritimive();
//遍历 d 的数组元素
for(int i = 0;i < d.t.length;i++){
System.out.println(d.t[i]);
}
//给 d 的数组元素重新赋值
d.t[0] = true;
d.t[1] = true;
d.t[2] = true;
for(int i = 0;i < d.t.length;i++){
System.out.println(d.t[i]);
}
}
}
class Pritimive{
boolean[] t = new boolean[3];
}
- 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。 成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’ 成绩>=最高分-30 等级为’C’ 其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
//import java.util.Scanner;
class TestStudentScore{
public static void main(String[] args) {
//1.创建Scanner 的对象，并从键盘获取学生的个数 n 。
Scanner s = new Scanner(System.in);
System.out.println("请输入学生的个数：");
int count = s.nextInt();//count用来记录学生的个数
//2.根据输入的学生的个数 n，创建一个长度为 n 的int 型的数组。
int[] scores = new int[count];
int maxScore = 0;
//3. 依次从键盘获取 n 个学生的成绩，并赋给相应的数组元素，并获取 n 个学生中的最高分。
System.out.println("请输入" + count + "个成绩：");
for(int i = 0;i < scores.length;i++){
int score = s.nextInt();//依次从键盘获取学生的成绩
scores[i] = score;
if(scores[i] > maxScore){
maxScore = scores[i];
}
}
//4.遍历学生成绩的数组，并根据学生成绩与最好分的差值，赋予相应的等级，并输出。
System.out.println("最高分为：" + maxScore);
for(int i = 0;i < scores.length;i++){
char level;
if(scores[i] >= maxScore - 10){
level = 'A';
}else if(scores[i] >= maxScore - 20){
level = 'B';
}else if(scores[i] >= maxScore - 30){
level = 'C';
}else{
level = 'D';
}
System.out.println("student " + i + " score is " + scores[i] + " grade is " + level);
}
}
}
二维数组
class TestArray2{
public static void main(String[] args) {
int[][] scores2;
String[][] names;
//1. 二维数组的初始化
scores2 = new int[][]{ {1,2,3}, {4,5,6}, {7} };//静态初始化
names = new String[6][5];//动态初始化的方式一
names = new String[6][];//动态初始化的方式二。先指定行数，
// names = new String[][6];//非法
// names = new String[][];//非法
names[0] = new String[5];//指定第几行有第几列
names[1] = new String[3];
names[2] = new String[4];
names[3] = new String[7];
names[4] = new String[8];
names[5] = new String[5];
//2. 如何来引用具体的某一个元素
int[][] i = new int[3][2];//int[] i[] = new int[3][2]; //一样
i[1][0] = 90;
i[2][1] = 100;
//3.数组的长度
//二维数组的长度，length 属性
System.out.println(i.length);//3 输出行数
//二维数组中元素的长度
System.out.println(i[0].length);//2 输出第一行的列数
//4.如何遍历二维数组
for(int m = 0;m < scores2.length;m++){//控制行数
for(int n = 0;n < scores2[m].length;n++){
System.out.print(scores2[m][n] + " ");
}
System.out.println();
}
// //5.内存结构
// int[] x,y[];
// //等同于
// int[] x;//一维 int x[];
// int[] y[];//二维 int y[][]; int[][] y;
}
}
数组的常见异常
class TestException{
public static void main(String[] args) {
//1. 数组下标越界的异常:java.lang.ArrayIndexOutOfBoundsException
int[] i = new int[10];
// i[0] = 90;
// i[10] = 99;//应为0~9
// for (int m = 0;m <= i.length;m++){//应为m < i.length
// System.out.println(i[m]);
// }
//2.空指针的异常：java.lang.NullPointerException
//第一种
// boolean[] b = new boolean[3];
//// b = null;//不应加该语句
// System.out.println(b[0]);
//第二种
// String[] str = new String[4];
// str[3] = new String("AA");//str[3] = "AA" //少了该语句后，str[3].toString()找不到地址
// System.out.println(str[3].toString());
//第三种
// int[][] j = new int[3][0];
// j[2][0] = 12;
}
}
获取 arr 数组中所有元素的和。使用 for 的嵌套循环即可。 3 8 2 2 7 9 0 1 6
class TestGetSum{
public static void main(String[] args) {
int[][] m = new int[][]{ {3, 8, 2},{2, 7},{9, 0, 1, 6} };
int sum = 0;
for (int i = 0;i < m.length;i++){
for(int j = 0;j < m[i].length;j++){
System.out.print(m[i][j] + "\t");
sum += m[i][j];
}
System.out.println();
}
System.out.println("总和为：" + sum);
}
}
使用二维数组打印一个 10 行杨辉三角. 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 ….
【提示】
- 第一行有 1 个元素, 第 n 行有 n 个元素
- 每一行的第一个元素和最后一个元素都是 1
- 从第三行开始, 对于非第一个元素和最后一个元素的元素. yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
//import java.util.Scanner;
class TestYangHui {
public static void main(String[] args) {
int[][] yangHui = new int[10][];
//1. 初始化二维数组
for(int i = 0;i < yangHui.length;i++){
yangHui[i] = new int[i + 1]; //指定某行有几列
}
//2. 显式的为二维数组的每个元素赋值。
for(int i = 0; i< yangHui.length; i++){
for(int j = 0; j < yangHui[i].length;j++){
yangHui[i][0] = yangHui[i][i] = 1;//每一行的第一列都为 1 。每一行的最后一列也都为 1 .
if (i > 1 && j > 0 && j < i){
yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
}
}
}
//遍历二维数组
for(int i = 0; i < yangHui.length;i++){
for (int j = 0;j < yangHui[i].length;j++){
System.out.print(yangHui[i][j] + "\t");
}
System.out.println();
}
}
}
class TestYangHui1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入杨辉三角的行数：");
int n = sc.nextInt();
int[][] triangle = new int[n][];
for (int i = 0; i < triangle.length; i++) {
triangle[i] = new int[i + 1];
for (int j = 0; j < triangle[i].length; j++) {
if (i == 0 || j == 0 || i == j) {
triangle[i][j] = 1;
} else {
triangle[i][j] = triangle[i - 1][j] + triangle[i - 1][j - 1];
}
System.out.print(triangle[i][j] + " ");
}
System.out.println();
}
}
}
1.求数组元素的最大值、最小值、平均数、总和等 2.数组的复制、反转 3.数组元素的排序
class TestArray3{
public static void main(String[] args) {
int[] arr = new int[]{11,15,12,13,18,2020,2019,23};
//最大值
int max = arr[0];//把数组中第一个值赋为最大值，再将其他值与其比较
for(int i = 1;i < arr.length;i++){//刚刚第一个值已拿出来，故而从第二个值开始
if(max < arr[i]){
max = arr[i];
}
}
System.out.println("数组的最大值为：" + max);
System.out.println();
// 最小值
int min = arr[0];
for(int i = 1;i < arr.length;i++){
if(min > arr[i]){
min = arr[i];
}
}
System.out.println("数组的最小值为：" + min);
System.out.println();
// 总和
int sum = 0;
for(int i = 0;i < arr.length;i++){
sum +=arr[i];
}
System.out.println("总和为：" + sum);
// 平均数
int avg = 0;
avg = sum / arr.length;
System.out.println("平均值为：" + avg);
//数组的复制
int[] arr1 = new int[arr.length];
for(int i = 0;i < arr1.length;i++){
arr1[i] = arr[i];
}
//遍历
for (int i = 0;i < arr.length;i++){
System.out.print(arr1[i] + "\t");
}
//数组的反转
//1.
for(int i = 0;i < arr.length/2;i++){
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
//遍历
System.out.println();
System.out.println("反转1后：");
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
//2.
for(int x = 0,y = arr.length - 1;x < y;x++,y--){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
//遍历
System.out.println();
System.out.println("反转2后：");
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
//使用冒泡排序使数组元素从小到大排序
/*
冒泡排序：排序思想：
相邻两元素进行比较，如有需要则进行交换，
每完成一次循环就将最大元素排在最后（如从小到大排序），
下一次循环是将其它的数进行类似操作。
*/
// for(int i = 0;i < arr.length - 1;i++){
// for(int j = 0;j < arr.length - 1 - i;j++){
// if(arr[j] > arr[j + 1]){
// //交换
// int temp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = temp;
// }
// }
// }
// //遍历
// System.out.println();
// System.out.println("排序后：");
// for (int i = 0;i < arr.length;i++){
// System.out.print(arr[i] + "\t");
// }
//
// //直接选择排序使数组元素从小到大排序
// for(int i = 0;i < arr.length - 1;i++){
// int t = i;//默认i处是最小的
// for(int j = i;j < arr.length;j++){
// //一旦在i 后发现存t在比其小的元素，就记录那个元素的下角标
// if(arr[t] > arr[j]){
// t = j;
//// int temp = arr[j];
//// arr[i] = arr[j];
//// arr[j] = temp;
// }
// }
// if(t != i) {
// int temp = arr[t];
// arr[t] = arr[i];
// arr[t] = temp;
// }
// }
Arrays.sort(arr);//可直接导入该包快速排序，手动写算法参考上边两则。
//遍历
System.out.println();
System.out.println("排序后2：");
for (int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
}
}
使用简单数组 (1)创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。 (2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。 (3)显示array1的内容。 (4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
思考：array1和array2是什么关系？ 拓展：修改题目，实现array2对array1数组的复制
class TestArry4{
public static void main(String[] args) {
int[] array1,array2;
array1 = new int[]{2,3,5,7,11,13,17,19};
//遍历array1
for(int i = 0; i < array1.length;i++){
System.out.print(array1[i] + "\t");
}
System.out.println();
array2 = new int[array1.length];
//给array2赋值
for(int i = 0;i < array2.length;i++){
if(i % 2 == 0){
array2[i] = i;
}else {
array2[i] = array1[i];
}
}
//遍历array2
System.out.println("array2:");
for(int i = 0; i < array2.length;i++){
System.out.print(array2[i] + "\t");
}
System.out.println();
//遍历array1
System.out.println("array1:");
for(int i = 0; i < array1.length;i++){
System.out.print(array1[i] + "\t");
}
}
}
韧桂 2019-12-30