目录
JAVA流程控制
1、顺序流程
按照从上向下执行的过程
2、分支流程
根据一定的判断条件，从满足条件的某一条分支运行程序
if else 分支流程
语法：
if(判断条件){
code1；
}else if(判断条件){
code2；
}
import java.util.Scanner; public class _03IfDemo { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入一个整数"); int num = scanner.nextInt(); if (num<0 || num>100) { System.out.println("输入有误"); } else if (num<60) { System.out.println("不及格"); } else if (num<80) { System.out.println("及格"); } else if (num<90){ System.out.println("良好"); } else { System.out.println("优秀"); } scanner.close(); } }
* 总结： * 1. 带有else语句块的分支结构，一定会执行某一条分支。 * 2. 不带else语句块的分支结构，可能一条分支都不执行。 * 3. if分支结构不可能执行多条分支。
switch-case分支流程
语法：
switch(variable){
case value1: code1;break;
case value2: code2;break;
case value3: code3;break;
......
}
import java.util.Scanner; public class Exercise02 { public static void main(String[] args) { Scanner Scanner = new Scanner(System.in); System.out.println("请输入一个年份"); int year = Scanner.nextInt(); System.out.println("请输入一个月份"); int month = Scanner.nextInt(); if (month < 1 || month >12){ System.out.println("输入不合理"); return;//关键字用于结束所在的方法，也就是不在执行后续代码 } String str = ""; boolean flag = false; int day = -1; if (year%4==0 && year%100!=0 || year%400==0) { str = "闰年"; flag = true ; }else { str = "平年"; } switch (month){ case 1: case 3:case 5:case 7:case 8:case 10: case 11: day = 31;break; case 4:case 6:case 9:case 12: day = 30;break; case 2: day = flag == true ? 29 : 28;//三元运算符需要一个变量来接受结果，所以下列式子是错的 // flag == true ? day=29 : day=28; // if (flag == true){ // day = 29; // }else { // day = 28; // } } System.out.println(year+ "是" + str +","+month+"="+day+"天"); } }
variable 是一个变量，用于判断与下面case的value值是否匹配，与哪个值匹配，就执行后面的code；
需要注意的是case具有穿透效果，若不想要穿透效果，case分支的code最后都需要加上break，否则若是满足第一个条件，且后续的case分支均没有加break，后续的每个语句均会一一穿透，直到最后。
3、循环流程
循环可以嵌套--外层循环一次，内层循环一遍
满足一定条件后，在一个循环体中，循环里面的代码，直到条件不满足后会退出循环
主要的循环结构有
for循环
语法：for(定义循环初试值;循环条件;循环步长)
{
循环体；
}
/** * for循环的其他写法 * 1. for循环的小括号里除了分号，其他都可以省略 * 2. 循环因子的声明和初始化，可以写在for循环之前 * 3. 循环步长可以写在循环体中 * 4. 循环条件可以不写，默认就是true。 */ public class _03ForDemo { public static void main(String[] args) { // 下面的写法，三部分都省略了，循环条件也省略了，相当于true.即死循环，程序要尽量避免死循环 /* for (;;) { System.out.println("Hello World"); }*/ // 循环因子的声明和初始化写在了for循环之前 int i = 1; for(;i<10;i++){ System.out.println("i = " + i); } //循环步长，写在循环体内 for(int m = 0;m<10;){ System.out.println("m = " + m); m+=3; //循环步长 } // 循环体中只有一行代码时，可以省略花括号 for(int n = 0 ; n < 10 ; n++) System.out.println("n="+n); int x = (int)(Math.random()*2); int y = (int)(Math.random()*2); // if分支里只有一行代码时，可以省略花括号 if(x==y) System.out.println("x和y相等"); else System.out.println("x!=y"); } }
for循环小括号中的所有值都可以省略，但是封号不能省略，相当于死循环；
循环条件不写，默认为true.
循环过程：将循环初始值定义为第1步，循环条件为第二步，循环步长为第三步，循环体定义为第四步；则基本过程为1,2,4,3,2,4,3...2,4,3直到最后三不满足条件时，退出循环，进行后续流程；
for循环若是遇到数组还有一种写法就是
for(定义初始值 : 要循环的数组){
循环体
}
while循环
语法：
while循环的起点在循环外定义；
while(循环条件){
循环体；
循环步长；
}
/** * while循环 * while(循环条件){ * 循环体 * } * */ public class _04WhileDemo { public static void main(String[] args) { /* 打印五次hello world int i = 0; while(i < 5){ System.out.println("hello world"); i++;//循环要素-循环步长// }*/ //打印100以内能背5整除的数，，计算 // int num = 0; // int n = 0; // while(num<101){ // if (num % 5 == 0) { // n = num; // System.out.println("100以内能背5整除的数:"+n); // num++; // }else { // num++; // } // // } // 打印100以内能背3整除的数，，计算被3整除的数的和 // int num = 0; // int n = 0; // int sum = 0; // while(num<101){ // if (num % 3 == 0) { // n = num; // sum +=num; // System.out.println("100以内能背5整除的数:"+n); // System.out.println("和为： " +sum); // num++; // }else { // num++; // } int num = 0; int n = (int)(Math.random()*1000000000+1); // int n = 0; System.out.println("生成的随机数："+n); while(n > 0) { n = n / 10; num++; } System.out.println("该数有"+num+"位"); // 利用循环打印i的内容 for (int i = 0; i < 5; i++) { System.out.println(i); } } }
Dowhile循环
先知执行循环体，后执行循环条件，
语法：
Do{
循环体；
}while(循环条件)
直到循环条件满足后才能退出循环
import java.util.Scanner; /** * do{ * 循环体 * }while(循环条件) * * 先执行循环体，在执行循环条件 * while,循环适合不知道循环次数的场景 * * for，适合知道循环次数的循环 * * do while, 适合先做执行体，再判断条件的场景 * */ public class _05DoWhileDemo { public static void main(String[] args) { String str = "123456"; String inputPWD = ""; Scanner scanner = new Scanner(System.in); //循环输入五次密码 do { System.out.println("请输入密码"); inputPWD = scanner.nextLine(); }while (!str.equals(inputPWD)); System.out.println("密码正确"); } }
4、关键字
continue
表示打断本次循环，进行下一次循环。
break
有打断，毁坏的含义，再循环结构中表示打断，跳过结束循环，继续执行后续的代码，
能力有限，只能打断结束其本身所在的那一层结构。
import java.util.Random; import java.util.Scanner; /** * 循环结构中的关键字-break * * break： 打断，毁坏的含义 * 在循环结构中表示打断，跳过，结束循环。继续执行后续代码 * * break ：只能结束其所在的那一层结构 */ public class _07BreakDemo { public static void main(String[] args) { //从1开始打印到100，遇到10循环结束 // for (int i = 0; i < 101; i++) { // if (i == 10) { // break; // } System.out.println(i); // } // System.out.println("----后续代码----"); /* 猜数字游戏，数字炸弹 */ Random random = new Random(); int num = random.nextInt(101); Scanner Scanner = new Scanner(System.in); System.out.println("请输入一个1~100的整数"); while(true){ int sc = Scanner.nextInt();//循环输入放在循环体内， //因为猜不对数要一直输入 if (sc == num) { System.out.println("猜对了"); break; } else if (sc > num) { System.out.println("猜大了"); } else { System.out.println("猜小了"); } } } }
JAVA中常用的工具类
1、Math工具类
静态常量：E：自然对数；PI：圆周率
取整函数：ceil()：向上取整
floor()：向下取整
rint()：取最近的整数；例如：rint(1.6) 得2，若是像3.5这种整数部分是奇数的都想向两句他最近的偶数部分取整。
常用函数：max()：取最大值
min()：取最小值
random()：随机数，范围[0,1) 与Random的nextDouble()取值一样
指数函数：pow()：幂函数；用法pow(底数,次方)
sqrt()：平方根；
cbrt()：立方根；
常见三角函数：sin(),cos(),tan(),asin(),acos(),atan()；
public class MathDemo01 { public static void main(String[] args) { System.out.println("自然对数：" +Math.E); System.out.println("圆周率：" +Math.PI); System.out.println("3,5比较取最大值：" +Math.max(3,5)); System.out.println("3,5比较取最小值：" +Math.min(3,5)); System.out.println("绝对值：" +Math.abs(-3)); // 使用Math.random()产生随机数 // [5,10) double v = Math.random() * 6 + 5; System.out.println("产生的随机数：" +v); System.out.println("3.4向上取整：" +Math.ceil(3.4)); System.out.println("3.4向下取整：" +Math.floor(3.4)); System.out.println("3.5最近的整数：" +Math.rint(18.5));//距离两边一样近，取偶数 System.out.println("4.4四舍五入：" +Math.round(4.5)); System.out.println("3的4次方：" +Math.pow(3,4)); System.out.println("8的平方根：" +Math.sqrt(8)); System.out.println("8的立方根：" +Math.cbrt(8)); } }
2、Random工具类
1.导包操作： import java.util.Random;
2.创建对象： Random random = new Random();
3.调用相关功能： random.nextInt(number); 产生一个[0,number)范围内的任意一个整数
random.nextdouble(); 产生一个[0,1)范围内的任意一个小数。
随机数取值范围区间;
[n,m] random.nextDouble()*(m+1-n)+n
[n,m) random.nextDouble()*(m-n)+n
import java.util.Random;
public class RandomDemo02 {
public static void main(String[] args) {
Random random = new Random();
// 随机产生 [0,10) 以内的任意小数
double v = random.nextDouble()*10;
// [0,10) 以内的任意整数
int num = (int)(random.nextDouble()*10);
// [-6,6] 以内的任意整数
int num1 = (int)(random.nextDouble()*13-6);
// 随机产生 [5,15] 以内的任意小数
int num2 = (int)(random.nextDouble()*11+5);
System.out.println("num2=" +num2);
int num3 = (int)(random.nextDouble());
System.out.println("num2=" +num2);
double d = random.nextInt(10)*10;
System.out.println("d=" +d);
}
}
3、Scanner工具类
前面三步基本与Random相似
1.导包操作： import java.util.Scanner;
2.创建对象： Scanner sc = new Scanner();
3.调用相关功能：可以使用打印语句来友好提示
System.out.println("请在控制台上输入一个年龄:");
int age = scan.nextInt();
4.最后如果后续代码不再使用扫描功能，需要关闭扫描功能。
sc.close();
常用功能：
nextBoolean(); 扫描控制台输入的boolean类型的数字
nextByte(); 扫描控制台输入的byte类型的数字
nextInt(); 扫描控制台输入的int类型的数字
nextShort(); 扫描控制台输入的short类型的数字
nextLong(); 扫描控制台输入的long类型的数字
nextFloat(); 扫描控制台输入的float类型的数字
nextdouble(); 扫描控制台输入的double类型的数字
next(); 扫描控制台输入的字符串，默认以空格或回车表示扫描结束。
nextline(); 扫描控制台输入的字符串，默认以回车表示扫描结束。
注意：所有的nextXXX方法，都有阻塞效果，即阻止程序向下执行，除非扫描到数据并结束扫描，
阻塞效果才会消失。
import java.util.Scanner; public class ScannerDemo01 { public static void main(String[] args) { // 步骤二：创建对象并使用 Scanner sc = new Scanner(System.in); // 步骤三：扫描控制台 // System.out.println("请输入姓名"); // String str = sc.next(); // // System.out.println("姓名：" +str); // System.out.println("请输入五个数字"); // int n1 = sc.nextInt(); // int n2 = sc.nextInt(); // int n3 = sc.nextInt(); // int n4 = sc.nextInt(); // int n5 = sc.nextInt(); // System.out.println(n1 + n2 + n3 + n4 + n5); System.out.println("请输入几个单词，用空格隔开"); //应使用nextLine(),next()遇到空格会默认阻隔结束； String word = sc.nextLine(); System.out.println("word为：" +word); sc.close(); } }
JAVA中的运算符
1、赋值运算符
= 最简单的赋值运算符, 将等号后的表达式的结果或者变量的值赋值给等号前面的变量
+= 如： 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
/** * 注释，有三种， 文档注释，多行注释，单行注释 * 文档注释: /** *\/ 一般用于类体上面或者是方法上面 * 单行注释: //..... 一般用于方法里，或者变量附近 * 多行注释: /* *\/ 一般用于方法里 * */ public class AssignSymbol01 { public static void main(String[] args) { int a = 10; int b = 20; a += b; // 相当于 a = a + b System.out.println(a);// 30 System.out.println(b);// 20 a -= b; // 相当于 a = a - b System.out.println(a); // 10 int c = 3; int d = 6; c *= d; System.out.println(c);//18 c = 15; c /=d; // 注意： 两个整数做除法运算，是取整操作 System.out.println(c); //2 int x = 15; int y = 6; x %= y; System.out.println(x);// 3 } }
2、关系运算符
>, >=, <, <=, ==, !=
作用：用于判断两边的大小关系。
返回值： boolean类型
代码示例：
public class RelationSymbolDemo01 { public static void main(String[] args) { int x = 10; int y = 20; System.out.println(x>y); // false System.out.println(x>=y); //false System.out.println(x<y); // true System.out.println(x<=y); // true System.out.println(x==y); // false System.out.println(x!=y); // true } }
3、逻辑运算符
逻辑或：|| 一真则真，全假则假
验证短路或 || * 真真==>真 * 真假==>真 * 假真==>真 * 假假==>假
逻辑与：&& 一假则假，全真则真
验证短路或 && * 真真==>真 * 真假==>假 * 假真==>假 * 假假==>假
逻辑非：！ 非假即真，非真即假
示例代码：
/** * 运算符-逻辑运算符 * 特点：如果已经可以确定第一个结果，就不再执行第二个条件，用于节省时间 * * 针对与短路与来说第一个是false时，不在看第二个条件，不管真假 * * 在JAVA中，一般研究的是短路运算符 * &&：短路与 ：一假则假，全真为真 * true&&true ==> true * true&&false ==> false * false&&true ==> false * false&&false ==> false * * ||：短路或 ：一真则真，全假则假 * * ! : 非真即假，非假即真 * */ public class LogicSymbolDemo01 { public static void main(String[] args) { //验真短路与 int a = 1,b = 2,c = 3,d = 4; boolean f = a < b && c < d; System.out.println("f的值为："+f);//true f = a < b && c++ > d; System.out.println("f的值为："+f);//false System.out.println("c的值为："+c); f = a > b && c < d; System.out.println("f的值为："+f);//false f = a > b && c > d; System.out.println("f的值为："+f);//false System.out.println("c的值为："+c); /* 验证短路或 || * 真真 真 * 真假 真 * 假真 真 * 假假 假 * */ int a1 = 1,b1 = 2,c1 = 3,d1 = 4; boolean s = a1 < b1 || c1 < d1; System.out.println("s的值为："+s);//true s = a1 < b1 || c1 > d1++; System.out.println("s的值为："+s);//true System.out.println("d1的值为："+d1);//4,没有执行自增，可以证明短路 s = a1 > b1 || c1 < d1; System.out.println("s的值为："+s);//true s = a1 > b1 || c1 > d1++; System.out.println("s的值为："+s);//false System.out.println("d1的值为："+d1);//5 ,当第一个条件可以判断，最终结果时，不再执行之后的表达试 System.out.println(2 << 3); // ! 非真即假，非假即真 f = !(1>2); System.out.println("f的值为："+f); f = !f; System.out.println("f的值为："+f); } }
4、三元用算符(三目运算符，条件运算符
语法： 判断条件（boolean类型的变量或表达式 ? 条件正确时的返回值 1: 条件错误时的返回值2
注意： * 1.该运算，依然遵守运算时转换为最大取值范围的那种类型； * 2.值1，值2，可以是变量，也可以是具有返回值的表达式； * 3.值1， 值2 的最终类型，需要自动类型转换 * 4.三目运算符的最终结果，需要一个变量来接收，该变量的类型应该是值1，值2中的一个；
示例代码:
public class ThreeEyeSymbolDemo01 { public static void main(String[] args) { int a = 1, b = 2; String str = a > b ? "是" : "否";//fou System.out.println("str的值为：" +str); //考虑值得最大类型范围，从大到小类型转换需要强转 int m = 10; long n = 15; long result = n%m==1?n:m; // 注意，需要考虑m和n在三目运算里都已经是long类型了。 System.out.println("result:"+result); } }
JAVA-方法
1.方法的结构
[访问权限的修饰词] [其他修饰词] 返回值类型 方法名(参数列表){
方法体；
return;
}
* 方法的返回值 * 1.方法在定义时，必须定义方法的返回值类型 * 2.返回值类型有两大类 * 第一种，void，无类型，不返回任何数据 * 第二种，JAVA中的任意类型，包括程序员自定义的 * 3.return关键字 * --含义是返回，归还 * --在方法中，表示结束方法，因此return ;后不能有任何代码，没有意义执行不到 * --void，类型的方法可加可不加 * --返回值是其他类型的方法，return关键字必须添加，并且return后必须有 * 一个返回该类型的变量或表达式，表示方法执行完毕后，最终数据返回给调用者 * 注意：调用该方法的所在处，就是调用者。
2.方法的参数列表
1.参数列表具体指的是定义期间方法名后放入的参数类型列表，列表指的是从左到右的顺序；类型非常重要，名字随意；
2.参数列表的语法：是0个以上的变量的声明语法，没有初始化操作；
3.参数列表里的参数名，称为形式参数，简称形参。
4.形式参数用于规定调用者在调用期间需要传入的数据的基本类型。
扩展：方法签名= 方法名 + 参数类型列表
比如：method(int a,double d,char c) 方法名为 method(int ,double ,char)
在同一个类体中，不能存在 方法签名相同的方法
5.方法的重载
在同一个类中，方法名相同参数类型列表不同，即方法签名不同，则认为该方法是之前方法的重载。
public static void m3(int a){System.out.println("--m3方法--"+a);}
// 和上面的m3(int)是重载关系
public static void m3(int a,int b){System.out.println("--m3方法--"+a);}
public class _03MethodDemo { public static void main(String[] args) { } public static void m1(int v,long e,String w){ System.out.println(v); } //和上面的m1是重载关系 public static void m1(double v,long e,String w){ System.out.println(v); } public static void m2(double v,long e,String w){ System.out.println(v); } public static int calculate(int a,int b,int c){ int max = Integer.MIN_VALUE; if (a > b && a > c) { max = a; } else if (b > a && b > c) { max = b; }else { max = c; } System.out.println(a); return max; } }
3.方法的调用
1.void类型，无返回值类型的。用 方法名(有参传参)，直接调用；
2.其他类型，有返回值类型的。用 返回值类型变量 变量 = 方法名(有参传参) 调用；
3.同一个类里的方法直接调用；
4.跨类的方法调用：需要通过对象名调用，也和方法的访问修饰符有关。
无参方法类型调用示例：
public class _04MethodDemo { public static void main(String[] args) { /*有形参列表的方法调用(无返回值类型)*/ // void System.out.println("开始"); myMethod01(); System.out.println("后续"); // 有返回值类型的方法调用 int i = myMethod02(); System.out.println(i); } public static void myMethod01(){ int a = 2; int b = 4; System.out.println(a); } public static int myMethod02(){ int a = 2; int b = 4; int sum = 0; for (int i = 0; i < 101; i++) { sum += i; } // System.out.println(a); return sum; } }有参方法的调用：
-有参方法调用必须传入参数且传入的实际参数列表和形式参数列表要相同，否则会编译失败，会 报实际参数列表和形式参数列表长度不同 错误
-实际参数，简称实参，在调用期间，传入到方法小括号里的变量，或者是具体的值；
-实参的作用：就是用于给形参赋值(传值),这个过程,称之为传参.
有参方法调用示例：
/** * 有参数的方法调用： * - 实际参数，简称实参。在调用时，传入到方法小括号里的变量，或者是具体值。 * - 实参的作用：就是用于给形参赋值(传值),这个过程,称之为传参. */ public class _01MethodDemo { public static void main(String[] args) { int m = 5; int n = 6; // 无返回值的调用 sum(m,n); /* 有具体返回值的方法调用 返回值类型 变量=返回值 */ //获取三个int类型数的最大值 int x = (int)(Math.random()*101); int y = (int)(Math.random()*101); int z = (int)(Math.random()*101); System.out.println("x="+x+",y="+y+",z="+z); //调用getmax(int a,int b,int c)方法 int max = getmax(x, y, z); System.out.println("max= "+max); } public static void sum(int a,int b) { a = 2*a; b += 5; int c = a + b; System.out.println(c); } public static int getmax(int a,int b,int c) { int max = Integer.MIN_VALUE; if (a > b && a > c) { max = a; } else if (b > a && b > c) { max = b; }else { max = c; } return max; } }
4.方法的递归
方法自己调用自己就叫方法的递归
实例演示：
/** * 方法的递归 * 自己调用自己 * * 设定 x = f(n) 计算20的阶乘 * * f(n) = f(n-1)*n; * 计算n 的阶乘 */ public class _02RecursionDemo { public static void main(String[] args) { // long sum = 1; // for (int i = 1; i < 21; i++) { // sum *= i; // } // System.out.println("sum = "+sum); long Re = Recursion(20); System.out.println("re="+Re); System.out.println(mysum(100)); } //定义一个递归方法，返回n的阶乘 public static long Recursion(int n){ //n为1是不需要调用方法 if (n == 1) { return 1; } return Recursion(n-1)*n; } /** * 定义一个递归方法，返回1~n的和。 * 方法名： mySum(int n) * 分析： * mySum(n) = mySum(n-1)+n * .... * mySum(2) = mySum(1)+2 * mySum(1) = 1; */ public static int mysum(int m) { int i = 1; if (m <= 0) { return 0; } return mysum(m-1)+m; } }
JAVA-数组
1、数组实例化：
1).使用new的两种方式；动态实例化
--new + 初始化元素内容
--new + 变量类型[长度] ；定义不同数据类型的数据默认元素不同
2).静态实例化
--数据类型[] 变量名 = {变量1,变量2,...}
--不能先声明在初始化
import java.util.Arrays; public class _01ArrayDemo { public static void main(String[] args) { // --new+初始化具体元素 String[] names = new String[]{"小红","小明","小强","张三","李四"}; //--new + 长度,,,注意，有默认元素 int[] nums = new int[5];// byte，short,int,long对应的默认元素是0 System.out.println(Arrays.toString(nums)); double[] prices = new double[10];// float double 对应的默认元素0.0 System.out.println(Arrays.toString(prices)); char[] ch = new char[10];//char 默认对应元素 \u0000 System.out.println(Arrays.toString(ch)); boolean[] boo = new boolean[5];//boolean 默认元素 false System.out.println(Arrays.toString(boo)); String[] str = new String[5];//引用类型 对应的默认元素 null System.out.println(Arrays.toString(str)); //使用静态初始化方式，实例化一个数组 // 该方式不能先声明在初始化 int[] numbers = {1,2,3,4,5}; } }
2、数组的访问
1)、通过下标访问，下标就是对应元素的索引值；
2)、数组下标从0开始访问，最后一个元素的下标是length-1
3)、数组长度的调用：数组(变量)名.length
代码示例：
import java.util.Arrays; public class _02ArrayDemo { public static void main(String[] args) { int[] ages = new int[]{20,19,18,18,17,16}; //获取ages 中的第一个元素 int first = ages[0]; System.out.println("first="+first); //获取ages 中的第四个元素 int four = ages[3]; System.out.println("four="+four); //直接打印最后一个元素 System.out.println("最后一个元素"+ages[ages.length-1]); //将年龄39，存入到第二个位置 ages[1] = 39; ages[ages.length-1] = 50; System.out.println(Arrays.toString(ages)); // 创建具有5长度的long类型数据 long[] ns = new long[5]; //将数字10,20，30,40,50，分别放入 ns[0] = 10; ns[1] = 20; ns[2] = 30; ns[3] = 40; ns[4] = 50; System.out.println(Arrays.toString(ns)); //将数字1~10存入到int类型的数组scores中 int[] scores = new int[10]; for (int i = 0; i < scores.length; i++) { scores[i] = i+1; } System.out.println(Arrays.toString(scores)); } }
3、学习Arrays工具类的用法
直接使用Arrays.调用以下方法 * 1. toString()：将数组转换(输出)为字符串形式。 "["+元素1+","+元素2+","+.....+"]" * 2. binarySearch()：在已排序的数组中查找指定元素的索引。二分查找 * 3. fill(数组名，指定值)：将数组的所有元素都设置为指定值。 * 4. sort(数组)：对数组进行排序。 * 5. copyOf()：将一个数组的部分或全部元素复制到一个新数组中。import java.util.Arrays; public class _11ArrayDemo { public static void main(String[] args) { int[] nums = {1,2,3,4,5}; String info = Arrays.toString(nums); System.out.println(info);//[5, 4, 3, 2, 1] System.out.println(Arrays.toString(nums)); //[5, 4, 3, 2, 1] //注意：工具类里的二分查找法，必须要数组升序排序 int index = Arrays.binarySearch(nums,4); System.out.println(index); //使用指定元素，填满整个数组 Arrays.fill(nums,100); System.out.println(Arrays.toString(nums)); //Arrays.sort(数组名)： 只能对已经提前设置好排序规则的类的数组进行排序。 int[] nums2 = {2,3,4,1,5}; Arrays.sort(nums2); System.out.println(Arrays.toString(nums2)); // 扩容: 将源数组的所有元素都拷贝到新数组的最前面，然后多余的位置是默认值， 注意：返回的是一个新的数组 int[] nums3 = Arrays.copyOf(nums2,10); // [1,2,3,4,5,0,0,0,0,0] // 指定的长度一样，因此可以理解为，完全拷贝。新数组和源数组一模一样 int[] nums4 = Arrays.copyOf(nums2,nums.length); // [1,2,3,4,5] // 指定的长度小于源数组的长度，可以理解为部分拷贝。注意是从头开始拷贝 int[] nums5 = Arrays.copyOf(nums2,3); System.out.println(Arrays.toString(nums5)); } }
4.数组异常报错
- 数组下标越界报错 ArrayIndexOutOfBoundsException
-1： 最小值越界
正值 ：最大值越界
1.代码在运行期间发生的
2.运行时异常，不会做任何操作，那么jvm会暴力终止程序；
- 空指针异常
1.在运行时发生的异常
2.使用了Null去访问各种方法或者属性 例如null.length()
5.增强for循环
也叫foreach循环，底层使用的是迭代器
for(元素类型 变量名: 数组|集合|枚举)
两者的对比 1.增强for循环中，没有下标的概念 2.增强for循环中，不能对数组中的元素进行改动 3.增强for循环中，比遍历下标执行效率更高
6.几种常见的排序方法
选择排序
原理：第一轮，拿下标为0的元素与后面的元素进行一一比较，满足条件就交换位置，第一轮会找到最大值或最小值；
第二轮，用下标为一的元素与之后的元素进行比较，满足条件就交换位置，直到倒数第二个元素停止，找到第二大或第二小的元素；
以此类推；
public class sout{ public static void main(String[] args) { int[] nums = {22,4,6,41,8,16,54,12}; for(int i = 0;i < nums.length-1;i++){ int temp = 0; for (int j = i+1;j < nums.length; j++ ) { if (nums[i]>nums[j]){ temp = nums[i]; nums[i] = nums[j]; nums[j] = temp; } } } for(int i = 0;i < nums.length-1;i++){ System.out.println(nums[i]); } } }
插入排序
import java.util.Arrays;
/**
* 插入排序
*/
public class _07ArrayDemo {
public static void main(String[] args) {
int[] nums = {34,45,234,67456,23,78,7423,67,4,4597,98,9789,67};
for (int i = 1; i < nums.length; i++) {
int j;
//每拿到一个元素判断是否要插入，小于就插入
if (nums[i] < nums[i-1]) {
int temp = nums[i];//将元素临时存起来
//查找要待插入的位置
for (j = i-1; j>=0&&temp<nums[j]; j--) {
//j位置上的元素比temp大，说明j位置的元素就向后移动；
nums[j+1] = nums[j];
}
//循环退出时，j的位置的元素应该小于或等于temp
nums[j+1] = temp;
}
}
System.out.println(Arrays.toString(nums));
}
}
冒泡排序
* 从左到右紧挨着的两个元素进行一一比较，满足条件就交换 * 第一轮找最大值； * 每一轮都找到，该轮的最大值 * 第一轮： 能找到最大值，冒泡到最右边。 * 比较五次 * 第二轮： 第二大元素冒泡到倒数第二个为止 * 比较4次 * ............. * 第五轮: 第五大元素冒泡的正数的第二个为止。 最后一个数不再需要比较了 * * 注意： 每一轮比较时，都是从最左边的两个元素开始的。import java.util.Arrays; /** * 冒泡排序 * * 6个元素： * i=0 j=5 * i=1 j=4 * i=2 j=3 * i=3 j=2 * i=4 j=1 j < length-1-i */ public class _08Arraydemo { public static void main(String[] args) { int[] arr = {23,35,354,5,68,234,46,7,3,234,12,345}; //外层循环控制轮数 for (int i = 0; i < arr.length-1; i++) { //内层是控制着每轮如何比较. 每次都要从左边开始比较，因此j从0开始 for (int j = 0; j < arr.length-i-1; j++) { // 如果前面的大于后面的，就做交换操作 if (arr[j]>arr[j+1]) { int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } System.out.println(Arrays.toString(arr)); } }
数组中元素查找
顺序查找
/** * 顺序查找； * */ public class _09ArrayDemo { public static void main(String[] args) { int[] nums = {100,56,23,45,234,567,34,23}; //要查找的数，找到了返回1；没找到返回-1 int index = select(nums,45); System.out.println(index); } public static int select(int arr[],int n){ // int index = -1; for (int i = 0; i < arr.length; i++) { if (arr[i] == n) { return 1; } } return -1; } }
二分查找
/** * 二分查找 */ public class _10ArrayDemo { public static void main(String[] args) { int[] nums = {1,2,3,4,5,6,7,8,9}; int num = binarySearch(nums,9); System.out.println(num); } /** * 写一个使用二分查找算法，从int类型的数组arr中找元素element的方法 * 找到，返回其坐标，没找到，返回-1 */ public static int binarySearch(int arr[],int element){ int min = 0, max = arr.length-1; // min<=max时，表示还没有找到该元素， min=max时，是最后一次查找 while (min<=max){ // 找到中间的元素下标 int mid = (min + max) / 2; if (arr[mid] == element) { return mid;//如果mid位置上的元素就是我们要找的，就返回下标 } else if (arr[mid] < element) {// 表示要找的元素，在中间值的右侧 min = mid + 1;//将min设置为中间下标+1. 然后重新循环 }else {//表示要找的元素在，中间值的左侧 max = mid - 1; } } //循环结束都没有遇到return,说明没有找到，就返回-1 return -1; } }
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
