java练习3 用栈进行括号匹配/** * @program: exercise * @description: 用栈进行括号匹配 * @author: yuuko * @create: 2021-12-12 15:42 **/ import java.util.Scanner; import java.util.Stack; public class KuoHao { public static void main(String[] args) { Scanner input=new Scanner(System.in); String s=input.next(); System.out.println(solution(s)); } public static boolean solution(String s){ Stack<Character> stack1=new Stack<>(); char currentCorrectChar; for(int i=0;i<s.length();i++) { switch (s.charAt(i)) { case '(': stack1.push(')'); break; case '[': stack1.push(']'); break; case '{': stack1.push('}'); break; default: if(stack1.isEmpty()) return false; else currentCorrectChar = stack1.pop(); if (currentCorrectChar != s.charAt(i)) return false; } } if(!stack1.isEmpty()) return false; return true; } }自定义栈进行括号匹配/** * @program: exercise * @description: 自己定义的栈 * @author: yuuko * @create: 2021-12-12 15:49 **/ public class myCharStack { private myCharStack header; private myCharStack next=null; private char content; myCharStack(){ this.header=this; } myCharStack(char content){ this.content=content; } public void push(char content){ myCharStack stack1=new myCharStack(content); stack1.next=this.header.next; this.header.next=stack1; } public char pop(){ if(this.header.next==null){ System.out.println("EmptyStackException here"); return 'X'; } char popContent=this.header.next.content; this.header.next=this.header.next.next; return popContent; } public boolean isEmpty(){ return this.header.next == null; } }/** * @program: exercise * @description: * @author: kkx * @create: 2021-12-12 15:57 **/ import java.util.Scanner; public class myKuoHao { public static void main(String[] args) { Scanner input=new Scanner(System.in); String s=input.next(); System.out.println(solution(s)); } public static boolean solution(String s){ myCharStack stack1=new myCharStack(); char currentCorrectChar; for(int i=0;i<s.length();i++) { switch (s.charAt(i)) { case '(': stack1.push(')'); break; case '[': stack1.push(']'); break; case '{': stack1.push('}'); break; default: currentCorrectChar = stack1.pop(); if (currentCorrectChar != s.charAt(i)) return false; } } if(!stack1.isEmpty()) return false; return true; } }

java学习笔记10 1. 理解“万事万物皆对象”1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构Scanner,String等 文件：File 网络资源：URL2. 涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。2、内存解析的说明引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）3. 匿名对象的使用理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象特征：匿名对象只能调用一次。java代码package com.atguigu.java; /** * @description: 匿名对象 * @author: kkx * @create: 2021-12-12 12:59 **/ public class InstanceTest { public static void main(String[] args) { Phone p = new Phone(); p.playGame(); new Phone().playGame(); new Phone().price = 1999; new Phone().showPrice(); //0.0 //常用 PhoneMall mall = new PhoneMall(); //匿名对象的使用 mall.show(new Phone()); } } class PhoneMall{ public void show(Phone phone){ phone.sendEmail(); phone.playGame(); } } class Phone{ double price; public void sendEmail(){ System.out.println("发送邮件"); } public void playGame(){ System.out.println("玩游戏"); } public void showPrice(){ System.out.println("价格为" + price); } }4. 自定义工具类的封装package com.atguigu.java; /** * @description: 工具类的封装 * @author: kkx * @create: 2021-12-12 13:38 **/ public class ArrayUtil { // 求数组的最大值 public int getMax(int[] arr){ int maxValue = arr[0]; for (int i = 1; i < arr.length; i++) { if (maxValue < arr[i]) { maxValue = arr[i]; } } return maxValue; } // 求数组的最小值 public int getMin(int[] arr){ int minValue = arr[0]; for (int i = 1; i < arr.length; i++) { if (minValue > arr[i]) { minValue = arr[i]; } } return minValue; } // 求数组的总和 public int getSum(int[] arr){ int sum = 0; for (int i = 0; i < arr.length; i++) { sum += arr[i]; } return sum; } // 求数组的平均值 public int getAvg(int[] arr){ return getSum(arr) / arr.length; } //如下的两个同名方法构成了重载 // 反转数组 public void reverse(int[] arr){ for (int i = 0; i < arr.length / 2; i++) { int temp = arr[i]; arr[i] = arr[arr.length - i - 1]; arr[arr.length - i - 1] = temp; } } public void reverse(String[] arr){ } // 复制数组 public int[] copy(int[] arr) { int[] arr1 = new int[arr.length]; for (int i = 0; i < arr1.length; i++) { arr1[i] = arr[i]; } return arr1; } // 数组排序 public void sort(int[] arr){ // 冒泡排序 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; } } } } // 遍历数组 public void print(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } System.out.println(); } // 查找指定元素 public int getIndex(int[] arr, int dest){ // 线性查找： for (int i = 0; i < arr.length; i++) { if (dest == arr[i]) { return i; } } return -1;//返回一个负数，表示没有找到 } }package com.atguigu.java; /** * @description: 使用自定义工具类 * @author: kkx * @create: 2021-12-12 13:44 **/ public class ArrayUtilTest { public static void main(String[] args) { ArrayUtil util = new ArrayUtil(); int[] arr = new int[]{32,34,32,5,3,54,654,-98,0,-53,5}; System.out.println("最大值为" + util.getMax(arr)); System.out.println("排序前："); util.print(arr); util.sort(arr); System.out.println("排序后："); util.print(arr); System.out.println("查找："); int index = util.getIndex(arr, -5); if(index >= 0){ System.out.println("找到了，索引地址为：" + index); }else{ System.out.println("未找到"); } util.reverse(arr); } }5. 方法的重载1. 定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。 "两同一不同":同一个类、相同方法名 参数列表不同：参数个数不同，参数类型不同2. 举例：Arrays类中重载的sort() / binarySearch()3. 判断是否是重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！4. 在通过对象调用方法时，通过方法名和参数列表确定方法5. java代码package com.atguigu.java1; /** * @description: 方法的重载 * @author: kkx * @create: 2021-12-12 13:56 **/ public class OverLoadTest { public static void main(String[] args) { OverLoadTest test = new OverLoadTest(); test.getSum(1, 2); //1 test.getSum(1.0, 2.0); //2 } //如果没有这个方法，则提升为double的方法 public void getSum(int i, int j){ System.out.println(1); } public void getSum(double d1, double d2){ System.out.println(2); } //传参数有顺序要求，顺序不一样也重载 public void getSum(String s ,int i){ System.out.println(3); } public void getSum(int i,String s){ System.out.println(4); } /* 如下的3个方法不能与上述4个方法构成重载 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系 public int getSum(int i,int j){ return 0; } public void getSum(int m,int n){ } private void getSum(int i,int j){ } */ }6. 可变个数形参的方法可变个数形参的格式：数据类型 ... 变量名当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。可变个数形参在方法的形参中，必须声明在末尾可变个数形参在方法的形参中,最多只能声明一个可变形参。package com.atguigu.java1; import java.util.Arrays; /** * @program: project10 * @description: 可变个数形参的方法 * @author: kkx * @create: 2021-12-13 20:51 **/ public class MethodArgsTest { public static void main(String[] args) { MethodArgsTest test = new MethodArgsTest(); test.show("hello world"); test.show(new String[]{"AA", "BB"}); } public void show(String s){ System.out.println("String s"); } public void show(String ... strings){ System.out.println("String ... strings"); System.out.println(Arrays.toString(strings)); } //不能与上一个方法同时存在 // public void show(String[] strs){ // // } }7. 关于变量的赋值基本数据类型，此时赋值的是变量所保存的数据值。引用数据类型，此时赋值的是变量所保存的数据的地址值。package com.atguigu.java1; /** * @program: project10 * @description: 关于变量的赋值 * @author: kkx * @create: 2021-12-13 22:41 **/ public class ValueTransferTest { public static void main(String[] args) { int m = 10; int n = m; System.out.println(m + "\t"+ n); n = 20; System.out.println(m + "\t"+ n); Order o1 = new Order(); o1.orderId = 1001; Order o2 = o1;//赋值以后，o1和o2的地址值相同 System.out.println(o1.orderId + "\t" + o2.orderId); o2.orderId = 1002; System.out.println(o1.orderId + "\t" + o2.orderId); } } class Order{ int orderId; }package com.atguigu.java1; /** * @program: project10 * @description: 方法的形参的传递机制：值传递 * @author: kkx * @create: 2021-12-13 23:12 **/ public class ValueTransferTest1 { public static void main(String[] args) { int m = 10; int n = 20; System.out.println(m + "\t" + n); //10 20 ValueTransferTest1 test = new ValueTransferTest1(); test.swap(m, n); System.out.println(m + "\t" + n); //10 20 } public void swap(int m, int n){ int temp = m; m = n; n = temp; } }package com.atguigu.java1; /** * @program: project10 * @description: 实现交换 * @author: kkx * @create: 2021-12-13 23:40 **/ public class ValueTransferTest2 { public static void main(String[] args) { Data data = new Data(); data.m = 10; data.n = 20; System.out.println(data.m + "\t" + data.n); //10 20 ValueTransferTest2 test = new ValueTransferTest2(); test.swap(data); System.out.println(data.m + "\t" + data.n); //20 10 } public void swap(Data data){ int temp = data.m; data.m = data.n; data.n = temp; } } class Data{ int m; int n; }8. 面试题/** * @program: project10 * @description: 面试坑1 * @author: kkx * @create: 2021-12-14 23:34 **/ public class test { public static void main(String[] args) { int a = 10; int b = 10; method(a, b); //仅输出a = 100,b = 200 System.out.println("a=" + a); System.out.println("b=" + b); } public static void method(int a, int b){ //自己编写 a = a * 10; b = b * 20; System.out.println(a); System.out.println(b); System.exit(0); } }/** * @program: project10 * @description: 面试坑2 * @author: kkx * @create: 2021-12-14 23:39 **/ public class test1 { public static void main(String[] args) { int[] arr = new int[]{1, 2, 3}; System.out.println(arr); //地址值 char[] arr1 = new char[]{'a', 'b', 'c'}; System.out.println(arr1); //abc } }9. 递归递归方法：一个方法体内调用它自身。方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。package com.atguigu.java1; /** * @program: project10 * @description: 递归 * @author: kkx * @create: 2021-12-17 00:35 **/ public class RecursionTest { public static void main(String[] args) { // 例1：计算1-100之间所有自然数的和 // 方式一： int sum = 0; for (int i = 1; i <= 100; i++) { sum += i; } System.out.println(sum); // 方式二： RecursionTest test = new RecursionTest(); System.out.println(test.getSum1(100)); System.out.println(test.f(10)); System.out.println(test.fibonacci(10)); } // 例1：计算1-n之间所有自然数的和 public int getSum(int n){ if (n == 1){ return 1; }else { return n + getSum(n - 1); } } // 例2：计算1-n之间所有自然数的乘积:n! public int getSum1(int n){ if (n == 1){ return 1; }else { return n * getSum(n - 1); } } //例3：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n), public int f(int n){ if (n == 0){ return 1; }else if(n == 1){ return 4; }else { return 2 * f(n - 1) + f(n - 2); } } //例4：斐波那契数列 public int fibonacci(int n){ if (n == 0){ return 0; }else if(n == 1){ return 1; }else { return fibonacci(n - 1) + fibonacci(n - 2); } } //例5：汉诺塔问题 //例6：快排 }

java学习笔记9 {music id="1381676207" color="#1989fa" /}1. java面向对象学习的三条主线Java类及类的成员：属性、方法、构造器；代码块、内部类面向对象的三大特征：封装性、继承性、多态性、(抽象性)其它关键字：this、super、static、final、abstract、interface、package、import等2. 面向对象和面向过程的区别面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。① 把冰箱门打开 ② 抬起大象，塞进冰箱 ② 把冰箱门关闭面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。人{ 打开(冰箱){ 冰箱.开开(); } 抬起(大象){ 大象.进入(冰箱); } 关闭(冰箱){ 冰箱.闭合(); } } 冰箱{ 开开(){} 闭合(){} } 大象{ 进入(冰箱){ } } 3. 面向对象的两个要素：类：对一类事物的描述，是抽象的、概念上的定义 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance) 面向对象程序设计的重点是类的设计。设计类，就是设计类的成员。4. 类和对象的使用创建类，设计类的成员属性 = 成员变量 = field = 域、字段方法 = 成员方法 = 函数 = method创建类的对象 = 类的实例化 = 实例化类创建类的对象通过“对象.属性”或“对象.方法”调用对象的结构如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。java代码package com.atguigu.java; public class PersonTest { public static void main(String[] args) { //2. 创建Person类的对象 Person p1 = new Person(); //调用对象的结构：属性、方法 //调用属性：“对象.属性” p1.name = "Tom"; p1.isMale = true; System.out.println(p1.name); //调用方法：“对象.方法” p1.eat(); p1.talk("中文"); Person p2 = new Person(); System.out.println(p2.name); //null System.out.println(p2.isMale); //false //将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。 Person p3 = p1; System.out.println(p3.name); //Tom p3.age = 10; System.out.println(p1.age); //10 } } //1.创建类，设计类的成员 class Person{ String name; int age = 1; boolean isMale; public void eat() { System.out.println("eat"); } public void sleep() { System.out.println("sleep"); } public void talk(String language) { System.out.println("说的是" + language); } }5. 类中属性的使用属性（成员变量） vs 局部变量相同点：定义变量的格式：数据类型 变量名 = 变量值先声明，后使用变量都有其对应的作用域不同点：在类中声明的位置的不同属性：直接定义在类的一对{}内 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量关于权限修饰符的不同属性：可以在声明属性时，指明其权限，使用权限修饰符。 常用的权限修饰符：private、public、缺省(default)、protected --->封装性。缺省常用。 局部变量：不可以使用权限修饰符。默认初始化值的情况：属性：类的属性，根据其类型，都有默认初始化值。整型（byte、short、int、long）：0浮点型（float、double）：0.0字符型（char）：0 （或'\u0000'）布尔型（boolean）：false引用数据类型（类、数组、接口）：null局部变量：没有默认初始化值。意味着，我们在调用局部变量之前，一定要显式赋值。特别地：形参在调用时，我们赋值即可。在内存中加载的位置：属性：加载到堆空间中 （非static）局部变量：加载到栈空间6. 类中方法的声明和使用1. 方法：描述类应该具有的功能。比如：Math类：sqrt()\random() ... Scanner类：nextXxx() ... Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ... 下面是自己写的类： public void eat(){} public void sleep(int hour){} public String getName(){} public String getNation(String nation){}2. 方法的声明：权限修饰符 返回值类型 方法名(形参列表){ 方法体 }注意：static、final、abstract 来修饰的方法3. Tip关于权限修饰符：默认方法的权限修饰符先都使用public。 Java规定的4种权限修饰符：private、public、缺省、protected返回值类型： 有返回值 vs 没有返回值如果方法有返回值，则必须在方法声明时，指定返回值的类型。并用return关键字来返回指定类型的变量或常量：“return 数据”。 如果方法没有返回值，用void来表示。通常，没有返回值则不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。我们定义方法该不该有返回值？题目要求凭经验方法名：属于标识符，遵循标识符的规则和规范，“见名知意”形参列表： 方法可以声明0个，1个，或多个形参。格式：数据类型1 形参1,数据类型2 形参2,...我们定义方法时，该不该定义形参？题目要求凭经验方法体：方法功能的体现。return关键字的使用：使用范围：使用在方法体中作用：结束方法针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。注意点：return关键字后面不可以声明执行语句。方法的使用中，可以调用当前类的属性或方法 特殊的：方法A中又调用了方法A:递归方法。 方法中，不可以定义方法。可以直接在同一个包下面定义自己的类，名字尾缀为java，最开始不需要importpackage com.atguigu.exer; public class Person { String name; int age; /** * sex:1 表明是男性 * sex:0 表明是女性 */ int sex; public void study(){ System.out.println("studying"); } public void showAge(){ System.out.println("age:" + age); } public int addAge(int i){ age += i; return age; } }package com.atguigu.exer; /* * 要求： * (1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法， * 输出字符串“studying”，调用showAge()方法显示age值， * 调用addAge()方法给对象的age属性值增加2岁。 * (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。 */ public class PersonTest { public static void main(String[] args) { Person p1 = new Person(); p1.name = "Tom"; p1.age = 18; p1.sex = 1; p1.study(); p1.showAge(); int newAge = p1.addAge(2); System.out.println(p1.name + "的新年龄为：" + newAge); System.out.println(p1.age); //20 Person p2 = new Person(); p2.showAge(); //0 p2.addAge(10); p2.showAge(); //10 } } 4. java代码package com.atguigu.java; public class CustomerTest { public static void main(String[] args) { Customer cust1 = new Customer(); //cust1.eat(); 报错 cust1.sleep(8); } } class Customer{ String name; int age; boolean isMale; private void eat(){ System.out.println("客户吃饭"); } public void sleep(int hour){ System.out.println("休息了" + hour + "个小时"); eat(); } public String getName(){ if (age > 18){ return name; }else { return "Tom"; } } public String getNation(String nation){ String info = "国籍为" + nation; return info; } }package com.atguigu.java; public class UserTest { public static void main(String[] args) { User u1 = new User(); System.out.println(u1.name); System.out.println(u1.age); System.out.println(u1.isMale); u1.talk("汉语"); u1.eat(); } } class User{ //属性（或成员变量） String name; public int age; boolean isMale; public void talk(String language){ //局部变量 System.out.println("我们用" + language); } public void eat(){ String food = "饼"; //局部变量 System.out.println("一个" + food); } }package com.atguigu.exer; public class StudentTest1 { public static void main(String[] args) { Student1[] s1 = new Student1[20]; for (int i = 0; i < s1.length; i++) { s1[i] = new Student1(); s1[i].number = (i + 1); //年级：[1,6] s1[i].state = (int)(Math.random() * (6 - 1 + 1) + 1); //成绩：[0,100] s1[i].score = (int) (Math.random() * (100 - 0 + 1)); } StudentTest1 test = new StudentTest1(); test.print(s1); System.out.println(); test.seacchState(s1, 3); System.out.println(); test.sort(s1); test.print(s1); } /** * 遍历学生数组 * @param s1 */ public void print(Student1[] s1){ for (int i = 0; i < s1.length; i++) { System.out.println(s1[i].info()); } } /** *问题一：打印出指定年级的学生信息。 * @param s1 要查找的数组 * @param state 要查找的年级 */ public void seacchState(Student1[] s1, int state){ for (int i = 0; i < s1.length; i++) { if (s1[i].state == state){ System.out.println(s1[i].info()); } } } /** * 使用冒泡排序按学生成绩排序 * @param s1 */ public void sort(Student1[] s1){ for (int i = 0; i < s1.length - 1; i++) { for (int j = 0; j < s1.length - 1 - i; j++) { if (s1[j].score > s1[j + 1].score){ //注意这里交换的是对象 Student1 temp = s1[j]; s1[j] = s1[j + 1]; s1[j + 1] = temp; } } } } } class Student1{ int number;; //学号 int state; //年级 int score; //成绩 //显示学生信息 public String info(){ return "学号：" + number + ",年级：" + state + ",成绩：" + score; } }

java学习笔记8 {music id="1406599484" color="#1989fa" autoplay="autoplay"/}数组常见算法1. 数组元素的赋值(杨辉三角，回文数等)杨辉三角package com.atguigu.exer; /* 使用二维数组打印一个 10 行杨辉三角。 【提示】 1. 第一行有 1 个元素, 第 n 行有 n 个元素 2. 每一行的第一个元素和最后一个元素都是 1 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即： yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j]; */ public class YangHuiTest { public static void main(String[] args) { //1.声明并初始化二维数组 int[][] yangHui = new int[10][]; //2.给数组的元素赋值 for (int i = 0; i < yangHui.length; i++) { yangHui[i] = new int[i + 1]; //2.1 给首末元素赋值 yangHui[i][0] = yangHui[i][i] = 1; //2.2 给每行的非首末元素赋值 for (int j = 1; j < yangHui[i].length - 1; j++) { yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j]; } //3.遍历二维数组 for (int j = 0; j < yangHui[i].length; j++) { System.out.print(yangHui[i][j] + "\t"); } System.out.println(); } } }2. 求数值型数组中元素的最大值、最小值、平均数、总和等package com.atguigu.java; public class ArrayTest1 { public static void main(String[] args) { int [] arr = new int[10]; for (int i = 0; i < arr.length; i++) { arr[i] = (int) (Math.random() * (99 -10 + 1) + 10); } //遍历 for(int i = 0;i < arr.length;i++){ System.out.print(arr[i] + "\t"); } System.out.println(); //求数组元素的最大值 int maxValue = arr[0]; for (int i = 1; i < arr.length; i++) { if (maxValue < arr[i]){ maxValue = arr[i]; } } System.out.println("最大值为：" + maxValue); //求数组元素的最小值 int minValue = arr[0]; for (int i = 1; i < arr.length; i++) { if (minValue > arr[i]){ minValue = arr[i]; } } System.out.println("最小值为：" + minValue); //求数组元素的总和 int sum = 0; for (int i = 0; i < arr.length; i++) { sum += arr[i]; } System.out.println("总和为：" + sum); //求数组元素的平均数 int avgValue = sum / arr.length; System.out.println("平均数为：" + avgValue); } }3. 数组的复制、反转、查找(线性查找、二分法查找)package com.atguigu.java; public class ArrayTest2 { public static void main(String[] args) { String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"}; //数组的复制 String[] arr1 = new String[arr.length]; for (int i = 0; i < arr1.length; i++) { arr1[i] = arr[i]; } //数组的反转 for (int i = 0; i < arr.length / 2; i++) { String temp = arr[i]; arr[i] = arr[arr.length - i - 1]; arr[arr.length - i - 1] = temp; } for (int i = 0, j = arr.length - 1; i < j; i++, j--) { String temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } //遍历 for(int i = 0;i < arr.length;i++){ System.out.print(arr[i] + "\t"); } System.out.println(); //查找 //线性查找 String dest = "BB"; dest = "CC"; boolean isFlag = true; for (int i = 0; i < arr.length; i++) { if (dest.equals(arr[i])){ System.out.println("位置为：" + i); isFlag = false; break; } } if (isFlag){ System.out.println("没找到"); } //二分法查找，效率高 //前提：所要查找的数组必须有序。 int [] arr2 =new int[]{-98,-34,2,34,54,66,79,105,210,333}; int dest1 = -34; dest1 = 35; int head_index = 0; //初始的首索引 int end_index = arr2.length - 1; //初始的末索引 boolean isFlag1 = true; while (head_index <= end_index){ int middle_index = (head_index + end_index) / 2; if (dest1 == arr2[middle_index]){ System.out.println("位置为：" + middle_index); isFlag = false; break; }else if(arr2[middle_index] > dest1){ end_index = middle_index- 1 ; }else { head_index = middle_index + 1; } } if (isFlag){ System.out.println("没找到"); } } }4. 排序算法1. 衡量排序算法的优劣：时间复杂度：分析关键字的比较次数和记录的移动次数空间复杂度：分析排序算法中需要多少辅助内存稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。2. 排序算法分类：内部排序和外部排序。内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。3. 十大内部排序算法选择排序直接选择排序堆排序交换排序冒泡排序快速排序插入排序直接插入排序折半插入排序Shell排序归并排序桶式排序基数排序4. 算法的5大特征输入（Input）：有0个或多个输入数据，这些输入必须有清楚的描述和定义输出（Output）：至少有1个或多个输出结果，不可以没有输出结果有穷性（有限性，Finiteness）：算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接受的时间内完成确定性（明确性，Definiteness）：算法中的每一步都有确定的含义，不会出现二义性可行性（有效性，Effectiveness）：算法的每一步都是清楚且可行的，能让用户用纸笔计算而求出答案5. java代码// 冒泡排序 package com.atguigu.java; public class BubbleSortTest { public static void main(String[] args) { int [] arr = new int[] {43,32,76,-98,0,64,33,-21,32,99}; 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; } } } for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } } }// 快速排序 package com.atguigu.java; public class QuickSort { private static void swap(int[] data, int i, int j) { int temp = data[i]; data[i] = data[j]; data[j] = temp; } private static void subSort(int[] data, int start, int end) { if (start < end) { int base = data[start]; int low = start; int high = end + 1; while (true) { while (low < end && data[++low] - base <= 0) ; while (high > start && data[--high] - base >= 0) ; if (low < high) { swap(data, low, high); } else { break; } } swap(data, start, high); subSort(data, start, high - 1);//递归调用 subSort(data, high + 1, end); } } public static void quickSort(int[] data){ subSort(data,0,data.length-1); } public static void main(String[] args) { int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 }; System.out.println("排序之前：\n" + java.util.Arrays.toString(data)); quickSort(data); System.out.println("排序之后：\n" + java.util.Arrays.toString(data)); } }5. Arrays工具类的使用常用的类作用boolean equals(int[] a,int[] b)判断两个数组是否相等。String toString(int[] a)输出数组信息。void fill(int[] a,int val)将指定值填充到数组之中。void sort(int[] a)对数组进行排序。int binarySearch(int[] a,int key)对排序后的数组进行二分法检索指定的值。java代码package com.atguigu.java; import java.util.Arrays; public class ArraysTest { public static void main(String[] args) { //1.boolean equals(int[] a,int[] b) int [] arr1 = new int[]{1,2,3,4}; int [] arr2 = new int[]{1,3,2,4}; boolean isEquals = Arrays.equals(arr1, arr2); System.out.println(isEquals); //false //2.String toString System.out.println(Arrays.toString(arr1)); //[1, 2, 3, 4] //3.void fill(int[] a,int val) Arrays.fill(arr1, 10); System.out.println(Arrays.toString(arr1)); //[10, 10, 10, 10] //4.void sort(int[] a) Arrays.sort(arr2); System.out.println(Arrays.toString(arr2)); //[1, 2, 3, 4] ////5.int binarySearch(int[] a,int key) 要有序 int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333}; int index = Arrays.binarySearch(arr3, 210); if (index >= 10){ System.out.println(index); }else { System.out.println("没找到"); } } }6. 数组使用中的常见异常数组角标越界的异常：ArrayIndexOutOfBoundsExcetion空指针异常：NullPointerExceptionjava代码package com.atguigu.java; public class ArrayExceptionTest { public static void main(String[] args) { //1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion int[] arr = new int[]{1,2,3,4,5}; //System.out.println(arr[5]); //System.out.println(arr[-2]); //2.2. 空指针异常：NullPointerException //情况一 int[] arr1 = new int[]{1, 2, 3}; arr1 = null; //System.out.println(arr1[0]); //情况二 int[][] arr2 = new int[4][]; //System.out.println(arr2[0][0]); 要初始化 //情况三： String[] arr3 = new String[]{"AA", "BB", "CC"}; //arr3[0] = null; System.out.println(arr3[0].toString()); } }

java学习笔记7 {music id="1861224068" color="#1989fa" autoplay="autoplay"/}1. 数组1. 概念数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理2. 组成数组名元素索引数组的长度：元素的个数3. 特点数组是有序排列的数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型创建数组对象会在内存中开辟一整块连续的空间数组的长度一旦确定，就不能修改。4. 数组分类按照维数：一维数组、二维数组、。。。按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组2. 一维数组1. 一维数组的使用一维数组的声明和初始化如何调用数组的指定位置的元素如何获取数组的长度如何遍历数组数组元素的默认初始化值 ：见ArrayTest1.java数组元素是整型：0 数组元素是浮点型：0.0 数组元素是char型：0或'\u0000'，而非'0' 数组元素是boolean型：false 数组元素是引用数据类型：null数组的内存解析 ：见ArrayTest1.javapackage com.atguigu.java; public class ArrayTest { public static void main(String[] args) { //1. 一维数组的声明和初始化 int [] ids;//声明 //1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行 ids = new int[]{01, 02, 03, 04, 05}; //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行 String [] names = new String[5]; int[] arr1 = new int[] {1,2,3,4,5}; int[] arr4 = {1,2,3,4,5};//类型推断 //2.如何调用数组的指定位置的元素:通过角标的方式调用。 names[0] = "00"; names[1] = "11"; names[2] = "22"; names[3] = "33"; names[4] = "44"; //3.如何获取数组的长度。(length) System.out.println(names.length); //4.如何遍历数组 for (int i = 0; i < names.length; i++) { System.out.println(names[i]); } } }package com.atguigu.java; public class ArrayTest1 { public static void main(String[] args) { //5.数组元素的默认初始化值 int [] arr = new int[4]; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } short [] arr1 = new short[4]; System.out.println(arr1[0]); float[] arr2 = new float[4]; System.out.println(arr2[0]); char[] arr3 = new char[4]; System.out.println(arr3[0]); //0 if(arr3[0] == 0){ System.out.println("你好！"); //进来这里 } boolean[] arr4 = new boolean[4]; System.out.println(arr4[0]); String [] arr5 = new String[4]; System.out.println(arr5[0]); //null if(arr5[0] == null){ System.out.println("北京天气不错！"); //进来这里 } } }2. 一维数组例题/* 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。 成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’ 成绩>=最高分-30 等级为’C’ 其余 等级为’D’ */ package com.atguigu.exer; import java.util.Scanner; public class ArrayDemo1 { public static void main(String[] args) { //1.使用Scanner，读取学生个数 Scanner scanner = new Scanner(System.in); System.out.println("学生人数"); int number = scanner.nextInt(); //2.创建数组，存储学生成绩：动态初始化 int[] scores = new int[number]; //3.给数组中的元素赋值 System.out.println("请输入" + number + "个学生成绩："); int maxScore = 0; for (int i = 0; i < scores.length; i++) { scores[i] = scanner.nextInt(); //4.获取数组中的元素的最大值:最高分 if (maxScore < scores[i]){ maxScore = scores[i]; } } //5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩 char level; for (int i = 0; i < scores.length; i++) { if (maxScore - scores[i] <= 10){ level = 'A'; }else if(maxScore - scores[i] <= 20){ level = 'B'; }else if(maxScore - scores[i] <= 30){ level = 'C'; }else{ level = 'D'; } System.out.println("student" + i + "成绩为" + scores[i] + "等级为" + level); } } }3. 二维数组1. 二维数组的概念对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。 其实，从数组底层的运行机制来看，其实没有多维数组2. 二维数组的使用:二维数组的声明和初始化如何调用数组的指定位置的元素如何获取数组的长度如何遍历数组数组元素的默认初始化值 :见 ArrayTest3.java针对于初始化方式一：比如：int[][] arr = new int4; 外层元素的初始化值为：地址值 内层元素的初始化值为：与一维数组初始化情况相同 针对于初始化方式二：比如：int[][] arr = new int[4][]; 外层元素的初始化值为：null 内层元素的初始化值为：不能调用，否则报错。数组的内存解析 :见 ArrayTest3.javapackage com.atguigu.java; public class ArrayTest2 { public static void main(String[] args) { //1.二维数组的声明和初始化 int [][] arr1 = new int [][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; String [][] arr2 = new String[3][2]; String [][] arr3 = new String[3][]; int arr4 [][] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}}; int[] arr5[] = {{1,2,3},{4,5},{6,7,8}}; //2.如何调用数组的指定位置的元素 System.out.println(arr1[0][1]); //2 System.out.println(arr2[1][1]); //null arr3[1] = new String[4]; // System.out.println(arr3[1][0]); //3.获取数组的长度 System.out.println(arr4.length); //3 System.out.println(arr4[0].length); //3 //4.如何遍历二维数组 for (int i = 0; i < arr4.length; i++) { for (int j = 0; j < arr4[i].length; j++) { System.out.print(arr4[i][j] + "\t"); } System.out.println(); } } }package com.atguigu.java; public class ArrayTest3 { public static void main(String[] args) { int [][] arr = new int[4][3]; System.out.println(arr); // 内存地址 System.out.println(arr[0]); // 内存地址 System.out.println(arr[0][0]); // 0 float [][] arr1 = new float[4][3]; System.out.println(arr1[0]); // 内存地址 System.out.println(arr1[0][0]); // 0.0 String[][] arr2 = new String[4][3]; System.out.println(arr2[0]); //地址值 System.out.println(arr2[0][0]); //null double[][] arr3 = new double[4][]; System.out.println(arr3[0]); //null //System.out.println(arr3[0][0]); //报错，空指针 } }