Java 基础
文章目录
一、基本语法
1、环境变量配置
2、测试环境变量
C:\Users\jacks>java -version
java version "1.8.0_231"
Java(TM) SE Runtime Environment (build 1.8.0_231-b11)
Java HotSpot(TM) 64-Bit Server VM (build 25.231-b11, mixed mode)
C:\Users\jacks>javac -version
javac 1.8.0_231
3、JDK、JRE和JVM的关系
4、Java文件编译->执行步骤
- 编写后缀为.java的代码
- 通过
javac命令对java文件编译 - 通过
java命令对生成的class文件进行运行
语法如下：
class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld!");
}
}
5、注释
1.单行注释和多行注释的作用：对所写的程序进行解释说明，增强可读性；
2.特点：注释的内容不参与编译；
3.文档注释的作用：注释的内容可以被JDK提供的javadoc工具所解析，生成一套以网页文件形式体现的该程序的说明文档。
- 单行注释：//
- 多行注释：/* */
- 文档注释（java独有）：/** */
6、Java API 文档
API：Application Programming Interface，习惯上将语言提供的类库都称为API；
API文档：针对于提供的类库如何使用，给的一个说明
7、关键字和保留字
关键字
保留字
java保留字：现有java版本尚未使用，以后的版本可能会作为关键字使用，自己命名时避免使用这些保留字。goto、const
8、标识符
java对各种变量、方法和类等要素命名时使用的字符序列称为标识符。
合法标识符规则
- 由26个英文字母大小写、0~9、_或$组成
- 不可以以数字开头
- 不可以使用关键字和保留字，但能包含关键字和保留字
- java中严格区分大小写，长度无限制
- 标识符不能包含空格
Java中名称命名规范
- 包名：多单词组成时所有字母都小写
- 类名、接口名：多单词组成时，所有单词的首字母大写
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写
- 常量名：素有字母都大写。多单词每个单词用下划线连接
9、变量
变量的概念
- 内存中的一个存储区域
- 该区域的数据可以在同一类型范围内不断变化
- 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值
变量的作用
- 用于在内存中保存数据
使用变量注意事项
- java中每个变量必须先声明，后使用
- 使用变量名来访问这块区域的数据
- 变量的作用域：其定义所在的一对{}内
- 变量只有在起作用内才有效
- 同一个作用域内，不能定义重名的变量
//变量使用前必须先声明，并赋值，才能使用变量
//通常定义整型变量使用int，byte和short会超，long太长
class VariableTest {
public static void main (String[] agrs){
//System.out.println ("my name is wangzhixin");
//变量的定义
int myAge=25;
//变量的使用
System.out.println(myAge);
//变量的声明
int myNumber;
//变量的赋值
myNumber = 1001;
System.out.println(myNumber);
//不可以在同一作用域定义同名变量
//int myAge = 18;
//定义byte类型
byte b1 = 12;
//注意byte范围：-128 ~ 127
//byte b2 = 128;
//定义short类型
short s1 = 129;
//定义int类型
int i1 = 1000;
//定义long类型，注意long必须以"l"或"L"结尾
long l1 = 7195785237L;
System.out.println(b1);
System.out.println(s1);
System.out.println(i1);
System.out.println(l1);
}
public void method(){
int myClass = 1;
}
}
变量的分类-按数据类型
对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间
- 基本数据类型
- 数值型：
- 整数类型
byte、short、int、long - 浮点类型
float、double
- 整数类型
- 字符型
char - 布尔型
boolean
- 数值型：
- 引用数据类型
- 类
class（字符串） - 接口
interface - 数组
array [ ]
- 类
整数类型
通常定义整型变量使用int，byte和short会超，long太长
浮点型
通常定义浮点型变量时使用double，原因范围更大，精度更高。定义float浮点型，注意float必须以"f"或"F"结尾
字符型
声明一个字符；转义字符；直接使用Unicode值来表示字符型常量
布尔型
只能取两个值之一：true、false；常用于条件判断、循环结构
基本数据类型的运算规则
- 自动类型提升
结论1：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型（*注：容量大小指的是数的范围大小）；
结论2：byte、char、short三种类型变量做运算时，结果为int类型；
byte、char、short- ->int- ->long- ->float- ->double
class VariableTest2 {
public static void main(String[] args) {
byte b1 = 2;
int i1 = 12;
//编译不通过
//byte b2 = b1 + i1;
int b2 = b1 + i1;
float f1 = b1 + i1;
System.out.println(b2);
System.out.println(f1);
}
}
class VariableTest3{
public static void main(String[] args){
char c1 = 'a'; //a底层数时97
int i1 = 10;
int i4 = c1 + i1;
System.out.println(i4);
byte b1 = 2;
//编译不通过
//byte b2 = c1 + b1;
int i2 = i1 + i4;
System.out.println(i2);
}
}
- 强制类型转换
结论1：需要使用强制转换符号:()；
结论2：强制类型转换，可能导致精度损失；
class VariableTest4{
public static void main(String[] args){
double d1 = 123.8;
//错误: 不兼容的类型: 从double转换到int可能会有损失
//编译不通过
//int i1 = d1;
//强制类型转换
int i1 = (int)d1; //截断操作（并非四舍五入，取整）
System.out.println(i1);
long l1 = 123;
short s2 = (short)l1;
System.out.println(s2);
int i2 = 128;
byte b1 = (byte)i2;
System.out.println(b1);
}
}
String 类型
1. String 属于引用数据类型，翻译为：字符串；
2. 声明String类型变量时，使用的一对双引号""；
3. String可以和8中基本数据类型变量做运算，且运算只能时连接运算。
class StringTest{
public static void main(String[] args){
String s1 = "Hello World!!!";
System.out.println(s1);
int number = 1404204;
String numberStr = "学号：";
String info = numberStr + number;//+：连接运算
System.out.println(info);
}
}
结论：String类型跟任何类型数据运算都是String
class String1 {
public static void main(String[] args){
char c = 'a';
int num = 10;
String str = "Hello";
System.out.println(c + num + str); //107Hello
System.out.println(c + str + num); //97Hello10 正确为：aHello10
System.out.println(c + (num + str)); //9710Hello 正确为：a10Hello
System.out.println((c + num) + str); //107Hello
System.out.println(str + num + c); //Hello1097 正确为：Hello10a
}
}
9
10、运算符
前++是+1后的值，后++是用+1之前的值
例：随机输入一个三位数，并分别打印百位、十位和各位
class FuHaoYunSun {
public static void main (String[] args){
int num = 188;
int bai = num / 100;
int shi = num % 100 / 10; //int shi = num / 10 % 10;
int ge = num % 10;
System.out.println ("百位为：" + bai);
System.out.println ("十位为：" + shi);
System.out.println ("个位为：" + ge);
}
}
逻辑运算符
& 与 && 的结论：
相同点：
①& 与 &&的运算结果相同；
②当符号左边为true时，二者都会执行符号右边的运算；
不同点：
①当符号左边为false时，&会继续执行符号右边的运算；&&不会执行符号右边的运算。
开发中推荐使用&&
//区分逻辑& 与 逻辑&&
//true 的区别
class LogicTest{
public static void main(String[] args) {
boolean b1 = true;
int num1 = 10;
if (b1 & (num1++ > 0)){
System.out.println("我在北京");
}else{
System.out.println("我在南京");
}
System.out.println("num1 = " + num1);
boolean b2 = true;
int num2 = 10;
if (b2 && (num2++ > 0)){
System.out.println("我在北京");
}else{
System.out.println("我在南京");
}
System.out.println("num2 = " + num2);
}
}
//输出结果如下：
我在北京
num1 = 11
我在北京
num2 = 11
//区分逻辑& 与 逻辑&&
//false 的区别
class LogicTest{
public static void main(String[] args) {
boolean b1 = false;
int num1 = 10;
if (b1 & (num1++ > 0)){
System.out.println("我在北京");
}else{
System.out.println("我在南京");
}
System.out.println("num1 = " + num1);
boolean b2 = false;
int num2 = 10;
if (b2 && (num2++ > 0)){
System.out.println("我在北京");
}else{
System.out.println("我在南京");
}
System.out.println("num2 = " + num2);
}
}
//输出结果如下：
我在南京
num1 = 11
我在南京
num2 = 10
| 与 || 的结论：
相同点：
①| 与 || 的运算结果相同；
②当符号左边为fause时，二者都会执行符号右边的运算；
不同点：
①当符号左边为true时，|会继续执行符号右边的运算；||不会执行符号右边的运算。
开发中推荐使用||
class LogicTest {
public static void main(String[] args){
boolean b1 = true;
int num1 = 10;
if (b1 | (num1++ > 0)){
System.out.println("我在北京");
}else{
System.out.println("我在南京");
}
System.out.println ("num1 = " + num1);
boolean b2 = true;
int num2 = 10;
if (b2 || (num2++ > 0)){
System.out.println("我在北京");
}else{
System.out.println("我在南京");
}
System.out.println ("num2 = " + num2);
}
}
//输出结果如下：
我在北京
num1 = 11
我在北京
num2 = 10
class LogicTest {
public static void main(String[] args){
boolean b1 = false;
int num1 = 10;
if (b1 | (num1++ > 0)){
System.out.println("我在北京");
}else{
System.out.println("我在南京");
}
System.out.println ("num1 = " + num1);
boolean b2 = false;
int num2 = 10;
if (b2 || (num2++ > 0)){
System.out.println("我在北京");
}else{
System.out.println("我在南京");
}
System.out.println ("num2 = " + num2);
}
}
//输入结果如下：
我在北京
num1 = 11
我在北京
num2 = 11
位运算符
结论：
①位运算符操作的都是整型的数据；
②<<：在一定范围内，每向左移1位，相当于* 2；
③>>：在一定范围内，每向右移1位，相当于 / 2
class BitTest {
public static void main(String[] args){
int i1 = 21;
int i2 = -21;
System.out.println ("i1 << 2 : " + (i1 << 2));
System.out.println ("i1 >> 2 : " + (i1 >> 2));
System.out.println ("i2 << 2 : " + (i2 << 2));
System.out.println ("i2 >> 2 : " + (i2 >> 2));
}
}
输出结果如下：
i1 << 2 : 84
i1 >> 2 : 5
i2 << 2 : -84
i2 >> 2 : -6
变量交换
class BianLiangJiaoHuan {
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
System.out.println("num1 = " + num1);
System.out.println("num2 = " + num2);
//方式一：定义临时变量
//int tmp = num1;
//num1 = num2;
//num2 = tmp;
//System.out.println("num1 = " + num1);
//System.out.println("num2 = " + num2);
//方式二：
//好处是不用定义临时变量
//弊端：①是相加炒作可能超出存储范围；
//②有局限性，只适用于数值类型
//num1 = num1 + num2;
//num2 = num1 - num2;
//num1 = num1 - num2;
//System.out.println("num1 = " + num1);
//System.out.println("num2 = " + num2);
//方式三:位运算符
//有局限性，只适用于数值类型
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;
System.out.println("num1 = " + num1);
System.out.println("num2 = " + num2);
}
}
//输出结果为：
num1 = 11
num2 = 20
num1 = 20
num2 = 11
三元运算符
①三元运算符可以嵌套使用；
②凡是可以使用三元运算符的，都可以使用if…else…，反之不成立，后者实用型比较大，推荐使用if…else…;
③能用三元也能用if…else…语句的，推荐使用三元运算符，效率更高，代码更简洁
例：获取两个正整数最大值
//根据条件表达式真或假，决定执行表达式1，还是表达式2
//结构：(条件表达式)? 表达式1：表达式2
//①条件表达式结果为boolean型
//②如果条件表达式为true，则执行表达式1
//③如果条件表达式为false，则执行表达式2
//④表达式1和表达式2必须要求一致
class MaxTest{
public static void main(String[] args) {
int m = 12;
int n = 5;
int max = (m > n)? m : n;
System.out.println(max);
double max1 = (m > n)? 2 : 1.0;
System.out.println(max1);
String maxStr = (m > n)? "m大" : "n大";
System.out.println(maxStr);
n = 12;
String maxStr1 = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
System.out.println(maxStr1);
}
}
//输出结果如下：
12
2.0
m大
m和n相等
例：获取三个数中的最大值
class MaxTest3{
public static void main(String[] args) {
int n1 = 1;
int n2 = 30;
int n3 = -8;
int max1 = (n1 > n2)? n1 : n2;
int max2 = (max1 > n3)? max1 : n3;
System.out.println("三个数中的最大值为：" + max2);
}
}
//输出结果如下：
三个数中的最大值为：30
案例：自动获取不同数据类型：
import java.util.Scanner;
class ScannerTest1 {
public static void main (String[] args){
Scanner scan = new Scanner(System.in);
//System.out.println("请随机输入一个数字：");
//int num = scan.nextInt();
//System.out.println("您输入的数值为：" + num);
System.out.println("请输入您的姓名：");
String name = scan.next();
System.out.println("您的姓名为："+name);
System.out.println("请输入您的芳龄：");
int age = scan.nextInt();
System.out.println("您的芳龄为：" + age);
System.out.println("请输入您的体重：");
double weight = scan.nextDouble();
System.out.println("您的体重为：" + weight + "kg");
System.out.println("您是否单身？（true/false）");
boolean isLove = scan.nextBoolean();
System.out.println(isLove);
//对于char类型数据的获取，Scanner没有提供相关的方法。只能获取一个字符串。
System.out.println("请输入您的性别：（男/女）");
String sex = scan.next();
char sexChar = sex.charAt(0);//获取索引为0位置上的字符
System.out.println(sexChar);
}
}
案例：if…else…使用
import java.util.Scanner;
class IfElseTest {
public static void main (String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入您的成绩：（0~100）");
int score = scan.nextInt();
System.out.println("您的成绩为：" + score);
if (score == 100){
System.out.println("奖励一辆宝马车！");
}else if (score > 80 && score <= 99){
System.out.println("奖励一台iPhone XS MAX！");
}else if (score >= 60 && score <= 80){
System.out.println("奖励一台iPad");
}else{
System.out.println("啥奖励也没有");
}
}
}
11、程序流程控制
11.1 顺序结构
11.2 分支结构
案例：随机输入三个整数并从小到大排序
import java.util.Scanner;
class CompareTest1{
public static void main(String[] args){
Scanner myScan = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int num1 = myScan.nextInt();
System.out.println("请输入第二个整数：");
int num2 = myScan.nextInt();
System.out.println("请输入第三个整数：");
int num3 = myScan.nextInt();
if (num1 >= num2){
if (num3 >= num1){
System.out.println("三个数一次从小到大排序为：" + num2 + "、" + num1 + "、" + num3);
}else if (num3 <= num2){
System.out.println("三个数一次从小到大排序为：" + num3 + "、" + num2 + "、" + num1);
}else{
System.out.println("三个数一次从小到大排序为：" + num2 + "、" + num3 + "、" + num1);
}
}else {
if (num3 >= num2){
System.out.println("三个数一次从小到大排序为：" + num1 + "、" + num2 + "、" + num3);
}else if (num3 <= num1) {
System.out.println("三个数一次从小到大排序为：" + num3 + "、" + num1 + "、" + num2);
}else{
System.out.println("三个数一次从小到大排序为：" + num1 + "、" + num3 + "、" + num2);
}
}
}
}
获取随机数
//随机获取[40,80)，其中默认范围为：[0.0,1.0)
int value = (int)(Math.random() * 41 + 40);
System.out.println("从[40，80)获取的随机数为：" + value);
//获取随机数公式：如，获取随机数范围[a,b)
//int value = (int)(Math.random() * (b - a + 1) + a )
案例
import java.util.Scanner;
class IfExer1{
public static void main(String[] args) {
Scanner myScan = new Scanner(System.in);
System.out.println("请输入您的身高(cm)：");
int height = myScan.nextInt();
System.out.println("请输入您的财富：");
double wealth = myScan.nextDouble();
//方式一：
//System.out.println("请输入是否帅？(true/false)：");
//boolean isHandsome = myScan.nextBoolean();
//方式二：
System.out.println("请输入是否帅?(是/否)");
String isHandsome = myScan.next();
if (height >= 180 && wealth >= 1 && isHandsome.equals("是")){
System.out.println("我一定要嫁给他!!!");
}else if (height >= 180 || wealth >= 1 || isHandsome.equals("是")){
System.out.println("嫁吧，比上不足，比下有余。");
}else {
System.out.println("不嫁!");
}
}
}
11.4 switc - case结构
①根据switch表达式中的值，一次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字火此switch-case结构末尾为止。
②break关键字，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。
③switch结构中的表达式，只能是如下6中数据类型之一：byte、short、char、int、枚举类型(jdk5.0新增)、String类型(jdk7.0新增)。
④case之后只能声明常量，不能声明范围。
⑤break关键字是可选的。
⑥default相当于if-else结构中的else，default结构是可选的，而且位置是灵活的。
案例，switch-case
import java.util.Scanner;
class SwitchCase1{
public static void main(String[] args) {
Scanner myScan = new Scanner(System.in);
System.out.println("请输入数值：");
int number = myScan.nextInt();
switch(number){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
default:
System.out.println("other");
}
}
}
switch-case 案例
import java.util.Scanner;
class seasonDay{
public static void main(String[] args){
Scanner myScan = new Scanner(System.in);
System.out.println("请输入季节？(spring/summer/autumn/winter)");
String season = myScan.next();
switch (season){
case "spring":
System.out.println("春暖花开");
break;
case "summer":
System.out.println("夏日炎炎");
break;
case "autumn":
System.out.println("秋高气爽");
break;
case "winter":
System.out.println("冬雪恺恺");
break;
default:
System.out.println("季节输入错误！");
}
}
}
11.3 循环结构
循环结构的四要素：
① 初始化条件；
② 循环条件 -->boolean 类型
③ 循环体
④ 迭代条件
- for 循环
基本结构
for (①;② ;④ ){
③
}
案例：遍历1~300，且3的倍数后面加foo，5的倍数后面加biz，7的倍数后面加baz
class ForTest2{
public static void main(String[] args) {
for (int i = 1;i <= 300 ;i++ ){
System.out.print(i + " ");
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();
}
}
}
获取两个数的最大公约数和最小公倍数
import java.util.Scanner;
class ForTest5 {
public static void main (String[] args){
Scanner myScan = new Scanner(System.in);
System.out.println("请输入正整数m：");
int m = myScan.nextInt();
System.out.println("请输入正整数n：");
int n = myScan.nextInt();
//获取最大公约数
int min = (m <= n)? m:n;
//遍历
for (int i = min;i >= 1;i--){
if (m % i == 0 && n % i == 0 ){
System.out.println(m +"和" + n + "的最大公约数为：" + i);
break;
}
}
//获取最小公倍数
int max = (m >= n)? m:n;
//遍历
for (int a = max;a <= m * n ;a++ ){
if (a % m == 0 && a % n == 0){
System.out.println(m + "和" + n + "的最小公倍数为：" + a);
break;
}
}
}
}
求水仙花数
水仙花数是一个3位数，各个位上数的立方等于本身即为水仙花数
class ForWattler {
public static void main(String[] args) {
for (int a = 100;a < 1000 ;a++ ){
if (a == ((a / 100) * (a / 100) * (a / 100)) + ((a % 100 / 10) * (a % 100 / 10) * (a % 100 / 10)) + ((a % 10) * (a % 10) * (a % 10))){
System.out.println("水仙花数为：" + a);
}
}
}
}
- while 循环
- while 循环要小心不要漏了迭代条件，一旦丢了可能会导致死循环；
- for 循环和 while 循环是可以想换转换的
- for 和while 循环的区别在于，初始化添加的作用范围不同，for出了作用范围不能调用，while 可以调用。
基本结构
①
while (②){
③;
④;
}
while 遍历100以内的偶数
class WhileTest{
public static void main(String[] args) {
//遍历100以内的偶数
int i = 1;
while (i <= 100){
if (i % 2 ==0){
System.out.println(i);
}
i++;
}
//此时依然而已调用，输出结果为101，for循环不能调用
System.out.println(i);
}
}
- do - while 循环
-
特点是至少会执行一次循环体。
基本结构
①
do{
③;
④;
}
while (②);
}
}
遍历1~100偶数并记录个数及计算总和
class WhileTest1{
public static void main(String[] args) {
//遍历100以内的偶数
int sum = 0; //记录总和
int count = 0; //记录个数
int i = 1;
do{
if (i % 2 ==0){
System.out.println(i);
sum += i;
count++;
}
i++;
}
while (i <= 100);
System.out.println("偶数的和为：" + sum);
System.out.println("偶数的个数为：" + count);
}
}
- 嵌套循环
嵌套循环案例：输入如下形状
/*
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
*/
class ForForTest7{
public static void main(String[] args) {
//输出上半部分
// 输出"-"
for (int i = 1;i <= 5 ;i++ ){
for (int j = 1;j <= 5 - i ;j++ ){
System.out.print(" ");
}
//输出"* "
for (int k = 1;k <= 0 + i ;k++ ){
System.out.print("* ");
}
System.out.println();
}
//输出下半部分
//输出"-"
for (int m = 1; m <= 4;m++ ){
for (int n = 1;n <= m + 0 ;n++ ){
System.out.print(" ");
}
//输出"* "
for (int l = 0;l <= 4 - m ;l++ ){
System.out.print("* ");
}
System.out.println();
}
}
}
嵌套循环：九九乘法表
class NineNineTable{
public static void main(String[] args) {
for (int i = 1;i <= 9 ;i++ ){
for (int j = 1;j <= i ;j++ ){
System.out.print(i + " * " + j + " = " + i * j + " ");
}
System.out.println();
}
}
}
- break、continue
- break：结束当前循环
- continue：结束当次循环
- break 和 continue 关键字后面不能声明执行语句
- 有循环嵌套时，默认跳出此关键字最近的一层循环
- 可以结束指定标识的一层循环结构
break 和 continue 案例
class BreakContinueTest{
public static void main(String[] args) {
for (int i = 1;i <= 10 ;i++ ){
if (i % 4 == 0){
break;
//continue;
}
System.out.println(i);
}
System.out.println();
label:for (int i = 1;i <= 4 ;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();
}
}
}
- return的使用
- return 并非专门用于结束循环的，它的功能是结束一个方法，当要给方法执行到一个return语句时，这个方法将被结束。
- 与break 和 continue 不同的是，return直接结束整个方法，不管这个return 处于多少层循环之内。
12、数组
12.1 数组(Array)
是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行管理。
12.2 数据的概念
- 数组名
- 下标、角标(或索引)
- 元素
- 数组的长度(元素的个数)
- 数组属于引用数据类型的变量。数组的元素，既可以是基本苏剧类型，也可以是引用数据类型
- 创建数组对象会在内存中开辟一整块连续的空间
- 数组的长度一旦确定，就不能修改
12.3 数组的分类
- 按照维数：一维数组、多维数组
- 按照数组元素类型：基本数据类型元素的数组、引用数据类型元素的数组
一维数组的使用
public class TelPhone {
public static void main(String[] args) {
int[] arr1 = new int[] { 4, 1, 2, 8, 9, 3 };
int arr2[] = new int[] { 1, 5, 2, 2, 4, 0, 1, 3, 1, 0, 1 };// 13229418141
String tel = "";
for (int i = 0; i < arr2.length; i++) {
tel += arr1[arr2[i]];
}
System.out.println("联系方式：" + tel);
}
}
案例：一维数组的使用
package com.jackson.exer;
import java.util.Scanner;
public class ArrayDemo1 {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
// 读取学生个数
System.out.print("请输入学生个数：");
int number = myScanner.nextInt();
// 创建数组，存储学生成绩，使用动态初始化
int[] scores = new int[number];
// 给数组中的元素赋值
int maxscore = 0;
System.out.print("请输入" + number + "个学生成绩:");
for (int i = 0; i < scores.length; i++) {
scores[i] = myScanner.nextInt();
if (scores[i] >= maxscore) {
maxscore = scores[i];
}
}
// 获取数组中元素最大值，即最高分
// int maxscore = 0;
// for (int i = 0; i < scores.length; i++) {
// if (maxscore < scores[i]) {
// maxscore = scores[i];
//
// }
// }
System.out.println("最高分为：" + maxscore);
// 求出离最高分的差值并分等级
char level;
for (int j = 0; j < scores.length; j++) {
if (scores[j] + 10 >= maxscore) {
level = 'A';
} else if (scores[j] + 20 >= maxscore) {
level = 'B';
} else if (scores[j] + 30 >= maxscore) {
level = 'C';
} else {
level = 'D';
}
System.out.println("Student " + j + " Score is " + scores[j] + " Grade is " + level);
}
}
}
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
