目录
数组
二维数组
总结
作业
Arrays工具类
数组
-
数组总结 及 静态初始化一维数组
/* Array: 1、java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object 2、数组实际上是一个容器，可以同时容纳多个元素（数组是一个数据的集合） 数组：字面意思是“一组数据” 3、数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据 4、数组因为是引用类型，所以数组对象存储在 堆内存 中 5、数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用(内存地址)” 数组中不能直接存储“java对象” 6、数组一旦创建，在java中规定，长度不可变。(数组长度不可变) 7、数组的分类：一维数组、二维数组、三维数组、多维数组。(一维数组较多，二维数组偶尔使用) 8、所有的数组对象都有length属性(java自带的)，用来获取数组中元素的个数 9、java中的数组要求数组中元素的类型统一，如：int类型的数组只能存储int类型，Person类型数组只能存储Person类型 例如：超市购物，购物袋中装了苹果，就只能装苹果，不能再装橘子。(数组中存储的元素类型统一) 10、数组在内存方面存储的时候，数组元中元素的内存地址是连续的(存储的每一个元素都是有规则的挨着排列的) 内存地址连续 11、所有的数组都是拿“第一个方框中的内存地址”作为整个数组对象的内存地址。 (数组中首元素的内存地址作为整个数组对象的内存地址) 12、数组中每一个元素都是有下标的，下标从0开始，以1递增，最后一个元素下标是length-1. 下标非常重要，因为我们对数组中元素进行“存取”的时候，都需要通过下标来进行。 13、数组这种数据结构的优点和缺点是什么？ 优点：查询/查找/检索某个下标上的元素时效率极高。可以说是查询效率最高的一个数据结构 为什么效率高？ 1、每一个元素的内存地址在空间存储上是连续的 2、每一个元素类型相同，所以占用空间大小一样 3、知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以通过一个数学表达式就可以计算出某个下标上元素的内存地址，直接通过内存地址定位元素，所以数组的检索率是最高的。 数组中存储100个元素，或存储100万个元素，在元素查询/检索方面，效率是相同的。因为数组中元素查找的时候不会一个一个找，是通过数学表达式计算出来的(算出一个内存地址，直接定位的) 缺点： 1、由于为了保证数组中每个元素的内存地址连续，所以在数组上随机增加/删除元素时，效率较低， 因为随机增删会涉及到后面元素统一向前或向后位移的操作。 2、数组不能存储大数据 因为很难在内存空间上找到一块特别大的连续的内存空间。 注意：对于数组中最后一个元素的增删，是没有效率影响的。 14、怎么声明/定义一个一维数组 语法格式： int[] array1; double[] array2; boolean[] array3; String[] array4; Object[] array5; 15、怎么初始化一个一维数组？ 包括两种方式：静态初始化一维数组，动态初始化一维数组。 静态初始化语法格式： int[] array = {100,2100,200,30}; 动态初始化语法格式： //初始化一个5长度的int类型数组，每个元素默认值：0 int[] array = new int[5]; //这里的5表示数组的元素个数。 //初始化一个6个长度的String类型数组，每个元素默认值：null String [] names = new String[6] */ public class ArrayText01 { public static void main(String[] args){ //声明一个int类型的数据，使用静态初始化的方式 int[] ii = {1,100,200,30,49,500}; //这是C++风格，虽然可以运行，但不建议在java中使用。 //int i[] = {1,100,200,30,49,500}; //所有的数组对象都有length属性 System.out.println("数组i中元素的个数："+ii.length); //数组中每一个元素都有下标，通过下标堆数组中的元素进行存和取。 //取(读) System.out.println("i数组中 第一个元素"+ii[0]); System.out.println("i数组中 最后一个元素"+ii[5]); System.out.println("i数组中 最后一个元素"+ii[ii.length-1]); //存(改) ii[0] = 111; ii[ii.length-1] = 888; System.out.println("i数组中 第一个元素"+ii[0]); System.out.println("i数组中 最后一个元素"+ii[5]); //一维数组 取遍历 for(int i = 0;i < ii.length;i++){//i<6,取到5就停止了。 System.out.println("ii数组中第"+(i+1)+"个元素："+ii[i]);// i是从 0 到 5，是下标 } //下标为6表示第七个元素，第七个元素没有，下标越界了，会出现什么异常呢？ //System.out.println(ii[6]);//ArrayIndexOutOfBoundsException 下标越界异常 //从最后一个元素遍历到第一个元素。 for(int i =ii.length-1 ; i>=0 ;i--){ System.out.println("ii数组中第"+(i+1)+"个元素："+ii[i]); } } } -
动态初始化一维数组，以及何时使用静态/动态初始化数组的方式。
/* 关于每个类型的默认值 数据类型 默认值 ------------------------------------ byte 0 short 0 int 0 long 0L float 0.0F double 0.0 boolean false char \u0000 引用数据类型 null 什么时候采用静态初始化方式，什么时候采用动态初始化方式？ 当创建一个数组时： 确定数组中存储哪些具体的元素时，采用静态初始化的方式。 不确定将来数组中存储哪些数据，可以采用静态初始化的方式，预先分配空间。 */ public class ArrayText02 { public static void main(String[] args){ //声明/定义一个数组，采用动态初始化的方式创建 int[] ii = new int[4]; //创建一个长度为4的int数组，数组中每个元素的默认值是0 //遍历数组 for (int i = 0 ; i < ii.length ; i++) { System.out.println("ii数组中下标为"+i+"的元素是:"+ii[i]); } //后期赋值 ii[0] = 111; ii[1] = 222; ii[2] = 333; ii[3] = 444;//注意下标不要越界 for (int i = 0 ; i < ii.length ; i++) { System.out.println("ii数组中下标为"+i+"的元素是:"+ii[i]); } //初始化一个Object类型的数组，采用动态初始化方式 Object[] objs = new Object[3]; //3个长度，动态初始化，所以每个元素默认值是null for (int i = 0 ; i < objs.length ; i++) { System.out.println("objs数组中下标为"+i+"的元素是:"+objs[i]); } System.out.println("===================="); // String[] strS = new String[3]; for (int i = 0 ; i < strS.length ; i++) { System.out.println("strS数组中下标为"+i+"的元素是:"+strS[i]); } //采用静态初始化的方式 String[] strS2 = {"abc","def","xyz"}; for (int i = 0 ; i < strS2.length ; i++) { System.out.println("strS2数组中下标为"+i+"的元素是:"+strS2[i]); } //存储Object ，采用静态初始化呢？ /* Object o1 = new Object(); Object o2 = new Object(); Object o3 = new Object(); Object[] objects = {o1,o2,o3}; */ //以上还可以简化为： Object[] objects = {new Object(),new Object(),new Object()}; for (int i = 0 ; i < objects.length ; i++) { System.out.println("objects数组中下标为"+i+"的元素是:"+objects[i]); /* 相当于： Object o = objects[i]; System.out.println(o); */ /* 输出结果：objects数组中下标为0的元素是:java.lang.Object@1b6d3586 objects数组中下标为1的元素是:java.lang.Object@4554617c objects数组中下标为2的元素是:java.lang.Object@74a14482 object[i] 输出的是此数组中存储的对象，即o1、o2、o3。输出引用会出输出这个对象的内存地址 而数组刚好就是存储内存地址的。 */ } } } -
当一个方法的参数类型为数组时，如何传参数
//当一个方法上，参数的类型是数组时，我们应该如何传递参数。 public class ArrayText03 { //java的main方法编写方式 //public static void main(String[] args) {} //还可以采用C++的语法格式！ public static void main(String args[]) { //java风格 int[] ii = {1,2,3}; for (int i = 0; i <ii.length ; i++) { System.out.println(ii[i]); } //C++风格 int ii2[] = {4,5,6}; for (int i = 0; i <ii2.length ; i++) { System.out.println(ii2[i]); } System.out.println("====================="); //调用方法时传一个数组进去 int[] x = {11,22,33,44,55,66}; printArray(x); String[] strS = {"hehe","haha","dudu","jiji"}; printArray(strS); String[] strArray = new String[2]; printArray(strArray); //也可以直接new 一个数组进去 printArray(new String[4]); printArray(new int[3]); } public static void printArray(int[] array){ for (int i = 0; i <array.length ; i++) { System.out.println(array[i]); } } public static void printArray(String[] args){ for (int i = 0; i <args.length ; i++) { System.out.println("String数组中的元素"+args[i]); } } } -
当一个方法的参数是一个数组时，我们还可以采用这种方式传输
//当一个方法的参数是一个数组时，我们还可以采用这种方式传输 public class ArrayText04 { public static void main(String[] args){ //静态初始化一维数组 int[] ii = {1,2,3}; printArray(ii); //动态初始化一维数组 int[] ii2 = new int[2]; printArray(ii2); printArray(new int[3]); System.out.println("================="); //没有这种语法 //printArray({1,2,3,4}); //如果直接传递一个静态数组的话，必须这样写： printArray(new int[]{1,2,3,4}); } //这里为什么用静态方法? //方便，不需要new对象。 public static void printArray(int[] array){ for (int i = 0; i <array.length ; i++) { System.out.println(array[i]); } } } -
main方法中的String[] args 作用：接收用户输入参数
/* main方法上面的String[] args 有什么用？ 分析一下：谁负责调用main方法——JVM JVM调用main方法时，会自动传一个String数组过来 */ public class ArrayText05 { //这个方法是程序员负责写出来，JVM负责调用，JVM调用的时候，一定会传一个String数组过来 public static void main(String[] args){ //JVM默认传过来的这个数组对象的长度：默认0 //通过测试得出：args不为null System.out.println("JVM给传递过来的String数组参数，它这个数组长度是："+ args.length); //以下这一行代码表示的含义：数组对象创建了，但是数组中没有任何数据。 String[] strS = new String[0]; String[] strS2 = {}; //静态初始化数组，里面没有传东西 printLength(strS); //0 printLength(strS2); //0 /* 这个数组什么时候里面会有值呢？ 其实这个数组是留给用户的，用户在控制台上输入参数，这个参数会自动被转换为“String[] args” 例如在cmd中这样运行程序：java ArrayText05 abc def xyz 那么这个时候JVM会自动将“abc def xyz” 通过空格的方式进行分离，分离完之后，自动放到“String[] args”数组当中 所以main方法上面的String[] args 数组主要是用来接收用户输入参数的 把abc def xyz 转换成字符串数组：{"abc","def","xyz"} */ //遍历数组 for (int i = 0; i <args.length ; i++) { System.out.println(args[i]); } } public static void printLength(String[] array){ System.out.println("数组长度为："+array.length); } } -
模拟一个系统，假设这个要使用必须输入用户名和密码
//模拟一个系统，假设这个系统要使用，必须输入用户名和密码 public class ArrayText06 { //用户名和密码输入到String[] args数组当中 public static void main(String[] args){ if(args.length != 2){ System.out.println("使用该系统时请输入程序参数，参数中包括用户名和密码信息，例如：zhangsan 123"); } //程序执行到这里说明用户确实提供了用户名和密码，接下来应该判断用户名和密码是否正确 //取出用户名 String useName =args[0]; //取出密码 String password =args[1]; //假设用户名是admin，密码是123的时候表示登录成功，其他一律失败。 //判断两个字符串是否相等，需要使用equals方法 //(useName.equals("admin")与(password.equals("123") //以下这样编写可以避免空指针异常 //采用以下编码风格，即使userName和password都是null，也不会出现空指针异常。 if("admin".equals(useName)){ if("123".equals(password)){ System.out.println("登录成功"); }else { System.out.println("密码输入有误，请确认后重新输入"); } }else { System.out.println("用户名输入错误"); } } } -
数组中存储的类型为：引用数据类型时
//一维数组的深入，数组中存储的类型为：引用数据类型。 //对于数组来说，实际上只能存储java对象的“内存地址”，数组中存储的每个元素都是“引用” public class ArrayText07 { public static void main(String[] args){ //创建一个Animal类型的数组 Animal a1 = new Animal(); Animal a2 = new Animal(); Animal[] animals = {a1,a2}; //对Animal数组进行遍历 for (int i = 0; i <animals.length ; i++) { /*Animal a = animals[i]; a.move();*/ //代码合并 animals[i].move(); //animals[i]取出下标为i的数据，因为这个数组是Animal类型的，所以可以调用Animal类中的move()方法 //这个move方法不是数组的，而是数组中存储的Animal对象的move方法 } //上与下原理相同 // int[] array = {1,2,3}; // for (int i = 0; i <array.length ; i++) { // /*int temp =array[i]; // System.out.println(temp); */ // //合并： // System.out.println(array[i]); // } //动态初始化要给长度为2的Animal类型数组 Animal[] animals1 = new Animal[2]; //创建一个Animal对象，放在数组的第一个盒子中 animals1[0] = new Animal(); //animals1[1] = new Product(); //Error: 不兼容的类型: Product无法转换为Animal //Animal数组中只能存放Animal类型，不能存放Product类型。 animals1[1] = new Cat(); animals1[1].move(); //创建一个Animal类型的数组，数组中存储Cat和Bird Animal[] animals2 ={new Cat(),new Bird()}; //该数组中存储了两个对象的内存地址 for(int i = 0 ; i <animals2.length ; i++){ //如果调用的方法是父类中存在的方法不需要向下转型，直接使用父类型引用调用即可 animals2[i].move(); //Cat c = animals2[i]; //Error: Animal无法转换为Cat 编译器只知道这个数组中存储的是Animal类型的对象，向下转型需要加强制类型转换 //Cat c = (Cat)animals2[i]; //Exception in thread "main" java.lang.ClassCastException: Bird cannot be cast to Cat //强制类型转换后报错，因为：Bird也是Animal类型的，也存储在Animal类型的数组中，需要动态判断 //当要调用子类中的特有方法时，需要向下转型，并加动态判断。 if(animals2[i] instanceof Cat){ Cat c = (Cat)animals2[i]; c.catchMouse(); }else if(animals2[i] instanceof Bird){ Bird b =(Bird)animals2[i]; b.sing(); } //animals2[i].sing(); //Error:(57, 28) java: 找不到符号符号: 方法 sing() 位置: 类 Animal } } } class Animal{ public void move(){ System.out.println("Animal move......"); } } //商品类 class Product{ } //Cat是Animal的子类 class Cat extends Animal{ @Override public void move() { System.out.println("猫走猫步!"); } public void catchMouse(){ System.out.println("猫抓老鼠"); } } class Bird extends Animal{ @Override public void move() { System.out.println("Bird Fei Fei Fei!"); } public void sing(){ System.out.println("鸟儿在唱歌！！"); } } -
数组的扩容，数组的拷贝
/* 关于一维数组的扩容 在java开发中，数组长度一旦确定后不可再改变，那么数组满了之后怎么办？ 数组满了，需要扩容 java中对数组的扩容： 先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。 结论：数组扩容效率较低，因为涉及到了拷贝的问题，所以在以后的开发中请注意：尽可能少的进行数据的拷贝。 可以在创建数组对象的时候预估计一下多长合适，最好预估准确，这样可以减少数组的扩容次数。提高效率。 */ public class ArrayText08 { public static void main(String[] args){ //java中数组扩容时使用System.arraycopy()方法进行拷贝 // System.arraycopy(5个参数); // public static native void arraycopy( // Object src, //拷贝源，需要扩容的小容量数组 // int srcPos, //从哪个位置开始，起始元素下标 // Object dest, //拷贝目标：要拷贝到的那个大容量数组中 // int destPos, //从哪个位置开始存放 // int length); //要拷贝的长度 //拷贝源（从这个数组中拷贝，需要扩容的数组） int[] src = {1,22,33,4,5}; //拷贝目标(拷贝到这个目标数组中) int[] dest = new int[10]; //初始化一个长度为10的数组，每一个元素默认值为0 //调用JDK中System类中的arraycopy方法，来完成数组的拷贝 System.arraycopy(src,1,dest,3,2); //遍历目标数组 for(int i = 0; i<dest.length;i++){ System.out.println(dest[i]); //0 0 0 22 33 ...... } //如要拷贝整个数组： System.arraycopy(src,0,dest,0,src.length); for (int i = 0; i <dest.length ; i++) { System.out.println(dest[i]); } //数组中如果存储的元素是 引用 ，可以拷贝吗？当然可以 String[] strings = {"hello","world","study","java","oracle","mysql","jdbc"}; String[] strings1 = new String[10]; System.arraycopy(strings,0,strings1,0,strings.length); for (int i = 0; i <strings1.length ; i++) { System.out.println(strings1[i]); } //Object类型的数组拷贝 Object[] objects = {new Object(),new Object(),new Object()}; Object[] objects1 = new Object[5]; //这里拷贝的时候不是拷贝对象，而是拷贝对象的内存地址。因为数组里存储引用数据类型时，存储的就是对象的内存地址。 System.arraycopy(objects,0,objects1,0,objects.length); for (int i = 0; i <objects1.length ; i++) { System.out.println(objects1[i]); } } }
二维数组
-
二维数组的初始化
/* 关于java中的二维数组 1、二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。 2、三维数组是什么？ 三维数组是一个特殊的二维数组，特殊在这个二维数组中每一个元素是一个一维数组。 实际的开发中使用最多的就是一维数组。二维数组也很少使用。三维数组几乎不用。 3、二维数组静态初始化 int[][] array = {{1,1,1},{10,20,30},{4,3,65,12,3,3}} */ public class ArrayText09 { public static void main(String[] args){ //一维数组 int[] array = {100,200,300}; System.out.println(array.length);//3 //二维数组 //里面的是四个一维数组,可以有n多个一维数组。 int[][] a = { {100,200,300}, {10,30,50}, {99,44,66,75,23}, {0} }; System.out.println("------------------"); System.out.println(a.length);//4 System.out.println(a[0].length);//3 这是a这个二维数组中下标为0的元素的那个一维数组的长度 System.out.println(a[1].length);//3 System.out.println(a[2].length);//5 System.out.println(a[3].length);//1 int[][] a2 = { {100,200,300}, {10,30,50}, {99,44,66,75,23}, {0}, {93,234,2938,493}, {102,3948,2} }; System.out.println(a2.length);//6 } } -
二维数组中元素的读和改
/* 关于二维数组中元素的：读和改 a[二维数组中一维数组的下标][二维数组中的一维数组中的元素下标] a[0][0]：表示第一个一维数组中的第一个元素。 a[3][100]:表示第四个一维数组中的第101个元素。 对于a[3][100]来说，其中a[3]是一个整体，[100]是前面a[3]直接结束的结果然后再下标100， */ public class ArrayText10 { public static void main(String[] args){ //二维数组 int[][] a = { {102,192,394}, {123,293,49}, {10,203,30} }; //请取出以上二维数组中的第一个一维数组，以及第一个一维数组中的第一个元素 int[] a1 = a[0]; System.out.println(a1[0]);//第一个元素 //合并： System.out.println(a[0][0]); //取出第二个一维数组中的第三个元素 System.out.println("第二个一维数组中的第三个元素:"+a[1][2]); //取出第3个一维数组中的第1个元素 System.out.println("第3个一维数组中的第1个元素:"+a[2][0]); //改 a[2][0] = 1111111; //修改数组3中的第一个元素后再次取出 System.out.println("修改后的第3个一维数组中的第1个元素:"+a[2][0]); //注意下标不能越界 } } -
二维数组的遍历
//二维数组的遍历 public class ArrayText11 { public static void main(String[] args) { String[][] strings ={ {"java","oracle","c++","python","C#"}, {"张三","李四","王五","赵七"}, {"lucy","ben","jack"}, }; //遍历二维数组 for (int i = 0; i <strings.length ; i++) {//二维数组中有几个一维数组循环几次，负责纵向 //负责遍历一维数组中的二维数组 for (int j = 0; j <strings[i].length ; j++) {//每个一维数组中有几个元素循环几次，string[i]表示二维数组中的一维数组 System.out.print(strings[i][j]+" ");//strings[i][j]表示二维数组中每个一维数组的元素 } //输出换行 System.out.println(); } } } -
动态初始化二维数组
//动态初始化二维数组 public class ArrayText12 { public static void main(String[] args){ //3行四列 //三个一维数组，每一个一维数组中有四个元素 int[][] ints = new int[3][4]; printArray(ints); //二维数组的遍历 // for (int i = 0; i <ints.length ; i++) { // for (int j = 0; j <ints[i].length ; j++) { // System.out.print(ints[i][j]+" "); // } // System.out.println(); // } //静态初始化 int[][] ints1 = { {1,1,1,1}, {2,2,2}, {3,3}, {4} }; printArray(ints1); //不能直接传这个进去，没有这种语法 //printArray({{1,1,1,1}, {2,2,2}, {3,3}, {4}}); //可以这样写 printArray(new int[][]{{1,1,1,1}, {2,2,2}, {3,3}, {4}}); } public static void printArray(int[][] array){ //遍历二维数组 for (int i = 0; i <array.length ; i++) { for (int j = 0; j <array[i].length ; j++) { System.out.print(array[i][j]+" "); } System.out.println(); } } }
总结
数组总结：
1、数组的优点和缺点，并且要理解为什么。
空间存储上，内存地址是连续的
每个元素占用的空间大小相同
知道首元素的内存储地址
通过下标可以计算出偏移量
通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，直接通过内存地址定位，效率非常高
优点：检索效率高
缺点：随机增删效率低，数组无法存储大数据量
注意：数组最后一个元素的增删效率不受影响。
2、一维数组的静态初始化和动态初始化
静态初始化：
int[] array = {1,2,3,4};
Object[] objs ={new Object(),new Object(),new Object()};
动态初始化：
int[] array = new int[4]; //四个长度的一维数组，每个元素默认值0
Object[] objs = new Object(4); //四个长度，每个元素默认值null
3、一维数组的遍历：
for(int i = 0; i< array.length ; i++){
System.out.println(array[i]);
}
4、二维数组的静态初始化 、动态初始化：
静态初始化：
int[][] array = {
{1,2,3,4},
{29,293,04,3984,38},
{10,293,84,85,919},
{0,4,3}
}
Object[][] array = {
{new Object(),new Object()},
{new Object(),new Object(),new Object(),new Object()},
{new Object(),new Object(),new Object()},
{new Object(),new Object(),new Object(),new Object(),new Object()}
}
动态初始化：
int[][] array = new int[3][4];
Object[][] array = new Object[4][4];
//Animal类型数组，里面可以存储Animal类型对象，以及Animal类型的子类型都可以。
Animal[][] array = new Animal[5][2];
5、二维数组的遍历
for(int i = 0; i < array.length ; i++){ //外层for循环负责遍历二维数组中的元素。
//内层for循环负责遍历一维数组里的元素
for(int j = 0 ; j <array[i].length ; i++){
System.out.print(array[i][j])
}
//换行
System.out.println();
}
6、main方法上“String[] args”参数的使用，（非重点，了解即可）
7、数组的拷贝：System.arraycopy()方法的使用
数组有一个特点：长度一旦确定，不可变
所以数组长度不够的时候，需要扩容，扩容的机制是：新建一个大数组。
将小数组中的数据拷贝到大数组，然后小数组对象被垃圾回收。
8、对数组中的数据拷贝到大数组，然后小数组对象被垃圾回收
9、对数组中存储引用数据类型的情况，要会画他的内存结构图。
作业
-
第一题：使用一维数组，模拟栈数据结构
自己做的
/* 第一题： 编写程序，使用一维数组，模拟栈数据结构。 要求： 1、这个栈可以存储java中的任何引用类型的数据。 2、在栈中提供push方法模拟压栈。（栈满了，要有提示信息。） 3、在栈中提供pop方法模拟弹栈。（栈空了，也有有提示信息。） 4、编写测试程序，new栈对象，调用push pop方法来模拟压栈弹栈的动作。 public class MyStack{ // 栈类 // 提供一个数组来存储栈中的元素 Object[] elements; // 栈帧（永远指向栈顶部的元素） // 每加1个元素，栈帧+1 // 每减1个元素，栈帧-1 int index; // 构造方法 // 构造方法是不是应该给一维数组一个初始化容量。 // push方法（push方法压栈） // 压栈表示栈中多一个元素。 // 但是栈如果已满，压栈失败。 // 这个方法的参数以及返回值类型自己定义。 // pop方法（pop方法弹栈） // 弹栈表示栈中少一个元素。 // 但是栈如果已空，弹栈失败。 // 这个方法的参数以及返回值类型自己定义。 } main(){ 测试... }*/ public class ArrayHomeWork1 { public static void main(String[] args) { MyStack ms1 = new MyStack(); System.out.println("压栈————————————————"); //压栈 ms1.push(new Object()); System.out.println(ms1.elements[0]); System.out.println(ms1.index); ms1.push(new Object()); System.out.println(ms1.elements[1]); System.out.println(ms1.index); System.out.println(ms1.elements[ms1.index-1]); ms1.push(new Object()); ms1.push(new Object()); ms1.push(new Object()); ms1.push(new Object()); ms1.push(new Object()); ms1.push(new Object()); ms1.push(new Object()); ms1.push(new Object()); System.out.println(ms1.elements[9]); ms1.push(new Object()); System.out.println(ms1.elements[ms1.index-1]); System.out.println("-------------------------------------------"); MyStack ms2 = new MyStack(2); System.out.println(ms2.elements.length); ms2.push(new Object()); ms2.push(new Object()); ms2.pop(); ms2.pop(); } } //每创建一个栈对象， class MyStack{ //栈类 //因为要求java中所有的数据类型都可以存储，所以数组类型要定义为Object类型的数组 Object[] elements ; //栈帧，指向最顶部的元素。 int index; //默认创建一个长度为10的一维数组 public MyStack(){ this.elements =new Object[10]; } //创建栈对象时，传进来一个数，把这个数作为栈的容量 public MyStack(int i){ //默认创建一个一位数组 this.elements = new Object[i]; } //压栈方法：push，表示在数组中增加一个元素 public void push(Object object){ if(this.index ==this.elements.length){ System.out.println("栈满了,压栈失败"); }else{ //压栈时，栈帧每次+1，此时传递一个元素进去，用下标接收，下标=栈帧-1， elements[index] = object; this.index += 1; System.out.println("压栈成功"); } } //弹栈方法 ：pop，表示在数组中删除一个元素 public void pop(){ //弹栈时，帧里有东西才会弹，如果没有，则弹栈失败。即：index大于0时才会弹栈，如果index为0，则说明栈中没有元素了 //所以大于0才会弹栈，弹栈后，栈里的元素-1， if(this.index > 0){ this.index -= 1; elements[index] = null; System.out.println("弹栈成功"); if(index == 0){ System.out.println("栈干净了"); } }else { System.out.println("栈已空，弹栈失败"); } } }根据视频做出来的
/* 编写程序，使用一维数组，模拟栈数据结构。 要求： 1、这个栈可以存储java中的任何引用类型的数据。 2、在栈中提供push方法模拟压栈。（栈满了，要有提示信息。） 3、在栈中提供pop方法模拟弹栈。（栈空了，也有有提示信息。） 4、编写测试程序，new栈对象，调用push pop方法来模拟压栈弹栈的动作。 5、假设栈的默认初始化容量是10，(请注意无参构造方法的编写方式) */ public class MyStack { //向栈中存储元素，我们这里使用一维数组模拟。存到栈中，就表示存储到数组中。因为数组是我们学习java的第一个容器 //为什么选择Object类型数组？因为这个栈可以存储java中的任何引用数据类型的数据。 //new Animal() 对象可以放进去，new Person()对象也可以放进去，因为Animal和Person的超级父类就是Object。 //包括String也可以放进去，因为String父类也是Object。 //注意：“abc”这是一个字符串对象，字符串在java中有优待，不需要new也是一个对象。“abc”字符串也是java对象，属于String类型。 private Object[] elements ;//private Object[] elements = new Object[10]; 也可以在这里直接赋值。 //栈帧，永远指向栈顶部元素 赋值-1，与下标同步增加。 private int index = -1; //无参构造方法 public MyStack() { //一维数组动态初始化，默认初始化为10。 this.elements = new Object[10]; } public MyStack(int i) { this.elements = new Object[i]; } //set和get也许用不上，但你必须写上，这是规矩。使用IDEA生成就可以。 //封装第一步：属性私有化，第二步：对外提供set和get方法。 public Object[] getElements() { return elements; } public void setElements(Object[] elements) { this.elements = elements; } //压栈的方法，object：被压入的元素 public void push(Object object){ if(this.index >= this.elements.length-1){ System.out.println("栈已满，压栈失败"); return; } //程序执行到这里，说明栈里还有空间，可以继续加元素 //this.index++ ; //elements[index] = object; //可合并为： ++index ，表示先加1再赋值，默认index为-1，压入后index为0，与压入元素的下标相同 elements[++index] = object; //所有的System.out.println()方法执行时，如果输出引用的话，自动调用引用的toString()方法。 System.out.println("元素 "+object+" 压栈成功，栈帧此时指向"+index); } //弹栈方法 public void pop(){ if(index <= -1){ System.out.println("栈已空，弹栈失败"); return; } //程序执行到这里说明栈还没空， System.out.println("元素 " + elements[index] +" 弹栈成功，此时栈帧指向："+ --index); } }测试
public class MyStackText { public static void main(String[] args){ //创建一个栈对象 MyStack stack = new MyStack(); //调用方法压栈 stack.push(new Object());stack.push(new Object());stack.push(new Object());stack.push(new Object());stack.push(new Object()); stack.push(new Object());stack.push(new Object());stack.push(new Object());stack.push(new Object());stack.push(new Object()); //压满之后 stack.push(new Object()); //栈已满，压栈失败 //弹栈 stack.pop();stack.pop();stack.pop();stack.pop();stack.pop(); stack.pop();stack.pop();stack.pop();stack.pop();stack.pop(); //栈空后 stack.pop();//栈已空，弹栈失败 //调用有参构造创建一个栈对象 MyStack stack2 = new MyStack(3); //压栈 stack2.push(new Object());stack2.push(new Object());stack2.push(new Object()); //栈满 stack2.push(new Object());//栈已满，压栈失败 //弹栈 stack2.pop();stack2.pop();stack2.pop(); //栈空 stack2.pop();//栈已空，弹栈失败 } } -
第二题：酒店管理系统
自己做没什么思路，根据老师说的做出来的
房间类
// 酒店房间 public class Room { /* * 房间编号： * 1楼：101 102 103 104 105..... * 2楼：201 202 203 204 205...... * 3楼：...... * ...... * */ private int no; //房间类型：单人间 双人间 总统套房 private String type; /* * 房间状态： * true：表示空闲，房间可以被预定 * flase：表示房间已被使用，不能再被订 * */ private boolean status; //构造方法 public Room() { } public Room(int no, String type, boolean status) { this.no = no; this.type = type; this.status = status; } //set和get方法 public int getNo() { return no; } public void setNo(int no) { this.no = no; } public String getType() { return type; } public void setType(String type) { this.type = type; } //idea工具类型的boolean类型的变量，生成的get方法的方法名：isXxx() //public boolean isStatus() { return status; } //如果你不喜欢，可以修改为：getXxx() public boolean getStatus() { return status; } public void setStatus(boolean status) { this.status = status; } /** * 自己做的时候没想到这里，不知道如何打印房间状态。 */ //equals方法重写 //equals是用来比较两个对象是否相等的 //如何比较，自己定。你认为两个房间编号相同，就表示同一个房间，那么你写代码编写比较房间编号就可以。 public boolean equals(Object obj) { if (obj == null ||!(obj instanceof Room)) return false; if (this ==obj) return true; Room room =(Room)obj; //如果两个房间的房间号相同，我们就说他们是同一个房间 return this.getNo() == room.getNo() ; } //toString方法重写 //toString方法的目的是将java对象转换成字符串形式。 //如何转，转成什么格式，自己定。目的：简单，清晰明了。 //如：这里不要看对象的内存地址。要看具体的信息 public String toString() { //return "[101,单人间，使用中]"; //return "[102,双人间，空闲]"; //动态打印出房间状态信息(把一个变量塞到一个字符串当中，口诀：加一个双引号，双引号中间加 + ，两个加号中间加变量名 【"+name+"】) //return "["+no+","+type+","+status+"]"; //status这里true时输出：空闲，false时输出：使用中，所以使用三目运算符 return "["+no+","+type+","+(status ? "空闲":"使用中")+"]"; //语法规则：布尔表达式？表达式1：表达式2 //当布尔表达式的结果是true时，选择表达式1作为整个表达式的执行结果。 //当布尔表达式的结果是false时，选择表达式2作为整个表达式的执行结果。 } //编写一个临时程序测试一下，测试完删除 /* public static void main(String[] args) { Room room = new Room(101,"单人间",true); Room room1 = new Room(102,"豪华VIP套间",false); System.out.println(room.toString()); System.out.println(room1);//room1是一个引用，输出引用时，会自动调用引用的toString()方法。 System.out.println(room.equals(room1)); //查看一个类中的所有的属性和方法快捷键：ctrl +F12 }*/ }酒店类
import java.util.Scanner; //酒店对象，酒店中有二维数组，二维数组模拟大厦 public class Hotel { //二维数组，模拟大厦的房间 private Room[][] rooms; //盖楼通过构造方法来盖 public Hotel(){ //一共有几层，每层的房间是什么，每个房间的编号是什么。 //我们可以先写死，一共三层，一层是单人间，二层是双人间，三层是总统套房。每层有10个房间 rooms = new Room[3][10]; //创建30个对象，放到数组当中。 //怎么放？二维数组遍历 for(int i = 0; i <rooms.length ;i++){//i是下标，i+1是楼层 //自己写的，还可以简化 // for(int j = 0 ; j <rooms[i].length;j++){ // rooms[i][j] = new Room(); // //初始化房间编号 // rooms[i][j].setNo((i+1)*100+j+1); // //每个房间初始时是空闲的 // rooms[i][j].setStatus(true); // //初始化房间类型 // if(i+1 ==1){ // rooms[i][j].setType("单人间"); // }else if(i+1 == 2){ // rooms[i][j].setType("双人间"); // }else if(i+1 == 3){ // rooms[i][j].setType("总统套间"); // } // } for (int j = 0; j <rooms[i].length ; j++) { if(i == 0){//一层 rooms[i][j] = new Room((i+1)*100+j+1,"单人间",true); }else if(i == 1){//二层 rooms[i][j] = new Room((i+1)*100+j+1,"双人间",true); }else if(i == 2){//三层 rooms[i][j] = new Room((i+1)*100+j+1,"总统套房",true); } } } } //想盖几层盖基层的有参构造，类型初始化尚待写入，无思路，以后再写 /* public Hotel(int a,int b){ System.out.println("已将酒店盖好，酒店共"+a+"层,每层有"+b+"个房间"); //二维数组，模拟大厦 rooms = new Room[a][b]; //使用二维数组遍历初始化房间。每一层房间的类型相同。 Scanner s = new Scanner(System.in); for (int i = 0; i <rooms.length ; i++) { for (int j = 0; j <rooms[i].length ; j++) { //在这里为每一层楼的每一个房间初始化 rooms[i][j] = new Room(); //初始化房间编号 //每一层的房间编号=这一层的层数*100+这个房间的房间号。 //因为数组下标都是从0开始，层数=i+1,房间号=j+1 rooms[i][j].setNo((i+1)*100+j+1); //所有的房间状态为：空闲 rooms[i][j].setStatus(true); } } }*/ //打印酒店房间状态的方法 public void printStatus(){ for(int i = 0; i <rooms.length ;i++){ for(int j = 0 ; j <rooms[i].length;j++){ System.out.print(rooms[i][j]+" "); } System.out.println(); } } //查看正在使用中的房间： public void printFalse(){ for(int i = 0; i <rooms.length ;i++){ for(int j = 0 ; j <rooms[i].length;j++){ if(rooms[i][j].getStatus() == false) System.out.print(rooms[i][j]+" "); } System.out.println(); } } /* 订房退房方法，调用时需要传递一个房间编号进来，这个编号是酒店前台输入的. 订房就是将房间状态false，退房是将房间状态true。 假设房间编号101，下标：rooms[0][0] 通过房间编号推出下标，获取房间对象 */ //订房方法 public void order(int roomNo){ Room r = rooms[roomNo/100-1][roomNo%10-1]; if(r.getStatus() == true){ r.setStatus(false); System.out.println(r); }else{ System.out.println("该房间已被使用，请确认要订的房间后重新输入"); } } //退房方法 public void out(int roomNo){ Room r = rooms[roomNo/100-1][roomNo%10-1]; if( r.getStatus()== false){ r.setStatus(true); System.out.println(r); }else { System.out.println("该房间已为空，请不要重复退房"); } } }测试类
import java.lang.reflect.Parameter; import java.util.Scanner; /* 第二题：（java软件工程师人生路上第一个小型项目。锻炼一下面向对象。） 为某个酒店编写程序：酒店管理系统，模拟订房、退房、打印所有房间状态等功能。 1、该系统的用户是：酒店前台。 2、酒店使用一个二维数组来模拟。“Room[][] rooms;” 3、酒店中的每一个房间应该是一个java对象：Room 4、每一个房间Room应该有：房间编号、房间类型、房间是否空闲. 5、系统应该对外提供的功能： 可以预定房间：用户输入房间编号，订房。 可以退房：用户输入房间编号，退房。 可以查看所有房间的状态：用户输入某个指令应该可以查看所有房间状态。 */ public class HotelManagementSystem { public static void main(String[] args) { Hotel hotel = new Hotel(); // hotel.printStatus(); // // hotel.order(102); // System.out.println("=-------------------------------===="); // hotel.printStatus(); //首先输出一个欢迎界面 System.out.println("欢迎使用酒店管理系统，请认真阅读使用说明"); while (true) { System.out.println("编号对应相应功能：【1】表示查看房间列表、【2】订房、【3】退房、【4】打印正在使用中的房间、【0】退出系统"); Scanner s = new Scanner(System.in); int i = s.nextInt(); if(i == 1){ hotel.printStatus(); }else if(i == 2){ System.out.println("请输入所要订的房间号"); Scanner roomNo = new Scanner(System.in); hotel.order(roomNo.nextInt()); }else if(i == 3){ System.out.println("请输入要退的房间号"); Scanner roomNo = new Scanner(System.in); hotel.out(roomNo.nextInt()); }else if(i == 0){ System.out.println("谢谢使用本系统，欢迎下次再来"); return; }else if(i == 4){ System.out.println("正在使用中的房间："); hotel.printFalse(); }else{ System.out.println("输入有误，请重新输入"); } } } }
Arrays工具类
常见的算法：
排序算法：
冒泡排序算法
选择排序算法
查找算法：
二分法查找
以上算法在以后的java实际开发中我们不需要使用的。因为java已经封装好了，直接调用就可以。以后面试时可能会碰到。
算法实际上在java中不需要精通，因为java中已经封装好了，要排序就调用方法就行。例如：java中提供了一个数组工具类：
java.util.Arrays
Arrays是一个工具类
其中有一个sort方法，可以排序。静态方法，直接使用类名调用就可以。
-
简单的排序
import java.util.Arrays; //使用一下SUN公司提供的数组工具类：java.util.arrays; public class ArraysText01 { public static void main(String[] args){ int[] ints = {2,8,4,6,193,123,39}; //工具类中的方法大部分都是静态的 Arrays.sort(ints); //遍历输出 for (int i = 0; i <ints.length ; i++) { System.out.println(ints[i]);//2 4 6 8 39 123 193 } } } -
冒泡排序算法
/* 冒泡排序算法 1、每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的那个气泡） 2、核心： 拿着左边的数字和右边的数字比对，当 左边 > 右边 的时候，交换位置。 原始数据： 3，2，7，6，8 第一次循环：（最大的跑到最右边） 2，3，7，6，8 3和2比较，2<3,所以2和3交换位置 2，3，7，6，8 虽然不需要交换位置：但是3和7还是需要比较一次 2，3，6，7，8 6<7 6和7交换位置 2，3，6，7，8 虽然不需要交换位置：但是7和8还是需要比较一次 经过第一次循环，此时剩下参与比较的数据：2，3，6，7 第二次循环 2，3，6，7 2和3比较，不需要交换位置 2，3，6，7 3和6比较，不需要交换位置 2，3，6，7 6和7比较，不需要交换位置 经过第二次循环，此时剩下参与比较的数据：2，3，6 第三次循环 2，3，6 2和3比较，不需要交换位置 2，3，6 3和6比较，不需要交换位置 经过第三次循环，此时剩下参与比较的数据：2，3 第四次循环 2，3 2和3比较，不需要交换位置 原始数据:9 8 10 7 6 0 11 第一次循环： 8 9 10 7 6 0 11 第1次比较后：交换 8 9 10 7 6 0 11 第2次比较后：不交换 8 9 7 10 6 0 11 第3次比较后：交换 8 9 7 6 10 0 11 第4次比较后：交换 8 9 7 6 0 10 11 第5次比较后：交换 8 9 7 6 0 10 11 第6次比较后：不交换 最终冒出的最大数据在右边：11 经过第一次循环，此时剩下参与比较的数据： 8 9 7 6 0 10 第二次循环 8 9 7 6 0 10 第1次比较后：不交换 8 7 9 6 0 10 第2次比较后：交换 8 7 6 9 0 10 第3次比较后：交换 8 7 6 0 9 10 第4次比较后：交换 8 7 6 0 9 10 第5次比较后：不交换 最终冒出的最大数据在右边：10 经过第二次循环，此时剩下参与比较的数据： 8 7 6 0 9 第三次循环 7 8 6 0 9 第1次比较后：交换 7 6 8 0 9 第2次比较后：交换 7 6 0 8 9 第3次比较后：交换 7 6 0 8 9 第4次比较后：不交换 最后冒出的最大数据在右边：9 经过第三次循环，此时剩下参与比较的数据：7 6 0 8 第四次循环 6 7 0 8 第1次比较后：交换 6 0 7 8 第2次比较后：交换 6 0 7 8 第3次比较后：不交换 最后冒出的最大数据在右边：8 经过第四次循环，此时剩下参与比较的数据：6 0 7 第五次循环 0 6 7 第1次比较后：交换 0 6 7 第2次比较后：不交换 最后冒出的最大数据在右边：7 经过第五次循环，此时剩下参与比较的数据：0 6 第六次循环 0 6 第1次比较后：不交换 //7条数据比6次 //6条数据比5次 //5条数据比4次 //4条数据比3次 //3条数据比2次 //2条数据比1次 */ public class BubbleSort { public static void main(String[] args){ //这是int类型的数组对象 // int[] arr = {3,2,7,6,8}; int[] arr = {9,8,10,7,6,0,11}; //经过冒泡排序算法对以上数组中元素进行排序 //冒泡排序算法的核心是什么？ //对arr数组中的七条数据进行冒泡排序 /* 数组中有七条数据，第一次循环7条数据要比较6次，第二次循环6条数据要比较5次，第三次循环5条数据要比较4次...第6次循环2条数据要比较1次 意思是：最外层循环要循环6次，内层循环每经过一次循环要根据所要比较的数据相应减少一次。 外层的是要控制需要进行6次循环比较，内层控制的是数组中数据的比较。 */ //查看循环几次 int count = 0; for (int i = arr.length-1; i >0 ; i--) { //i刚开始是6，循环到1，刚好是循环了6次 for (int j =0 ; j < i ; j++) { //不管是否交换，只要循环一次，就加1; count++; //内层循环里，j < i，就是几条数据循环几条-1次，如有5条数据，就循环四次 //交换位置 if(arr[j] >arr[j+1]){ int temp ; temp = arr[j]; arr[j] =arr[j+1]; arr[j+1] =temp; } } } for (int i = 0; i <arr.length ; i++) { System.out.println(arr[i]); } System.out.println("共比较了"+count+"次"); } } -
选择排序：
选择排序比冒泡排序的效率高，高在交换位置的次数上。选择排序的交换位置是有意义的
循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和最前面的数据交换位置。
/* 选择排序：每一次从 这堆参与比较的数据 当中找出 最小值 拿着这个 最小值 和 参与比较的这堆数据中最前面的元素 交换位置 选择排序比冒泡排序好在：每一次的交换位置都是有意义的。 参与比较的数据：3 1 6 2 5 （这一堆参加比较的数据中最左边的元素下标是0） 第一次循环之后的结果是：1 3 6 2 5 参与比较的数据： 3 6 2 5 （这一堆参加比较的数据中最左边的元素下标是1） 第二次循环之后的结果是：2 6 3 5 参与比较的数据是： 6 3 5 （这一堆参加比较的数据中最左边的元素下标是2） 第三次循环之后的结果是：3 6 5 参与比较的数据是：6 5 （这一堆参加比较的数据中最左边的元素下标是3） 第四次循环之后的结果是：5 6 注意：5条数据，循环4次。 关键点：选择排序中的关键在于：怎么找出一堆数据中最小的 3 1 6 2 5 假设： 第一个3是最小的 3和2比较，发现2更小，所以此时最小的是2 继续拿着2往下比对，2和6比较，2仍是最小的 继续拿着2往下比对，2和1比较，发现1更小，所以此时最小的是1 继续拿着1往下比对，1和5比较，1仍是最下的。 拿着1和最左边的3交换位置 2 6 3 5 假设： 第一个2是最小的 。。。 6 3 5 假设6是最小的： 6和3比对，发现3更小，所以此时最小的是3 */ public class SelectSort { public static void main(String[] args){ //int[] arr = {3,1,6,2,5}; int[] arr = {9,8,10,7,6,0,11}; //选择排序算法 5条数据循环4次 //每次循环取出最小的值与第一个值交换（外层循环4次） //设置个变量，查看比较次数 int count =0; //查看交换次数 int count2 = 0; for (int i = 0; i <arr.length-1 ; i++) { //i的值是 0 1 2 3 ，正好是参加比较的这堆数据中 最左边那个元素的下标 //假设起点i下标位置上的元素是最小的，把这个与所有的作比较，最后取出比这个小的 int min = i; //比较的时候,把第一个值与所有的值比较一遍后取出最小的与第一个值交换 for(int j = i+1 ; j < arr.length ;j++){//内层循环是：第一个值与所有的值相比较 count++; if(arr[j] < arr[min]){ //假设i是最小的值后，如果j的比最下的还小，则把j设为最小 min = j; } } //当i和min相等时，表示猜测是对的， //当i和min不相等时，表示猜测是错的，有比这个元素更小的元素，需要拿着这个更小的元素和最左边的元素交换位置 if(min != i){ count2++; //当最小的不是i时，最小的为min， int middle = arr[i]; //第左手给中间 arr[i] = arr[min]; //把右手给左手 arr[min] = middle; //中间（存放了左手）给右手 } } for (int i = 0; i <arr.length ; i++) { System.out.println(arr[i]); //1 2 3 5 6 //0 6 7 8 9 10 11 } //冒泡排序和选择排序实际上比较的次数没有变，交换位置的次数变少了 System.out.println("比较次数："+count); System.out.println("交换次数："+count2); } }结论：
冒泡排序和选择排序实际上比较的次数没有变，但选择排序的交换位置的次数变少了 -
数组元素的查找
挨着找：效率低
/* 数组的元素查找 数组元素查找有两种方式： 第一种方式：一个一个挨着找 第二种方式：二分法查找法(算法)，这个效率比较高。 */ public class ArraySearch { public static void main(String[] args) { //这个例子演示一下第一种方式 int[] arr ={4,5,5,6,87,8}; //如果有两个相同的元素，则返回的是第一个。因为是挨着找，找到后就结束了，不会再去找剩下的。 /* //找出87的下标，如果没有返回-1。 //一个一个挨着找 for(int i = 0; i < arr.length;i++){ if(arr[i] == 87){ System.out.println("87的元素的下标为："+i); return; } } //程序执行到这里，表示没有87 System.out.println("数组中不存在87这个元素");*/ /* 最好以上的程序封装一个方法，思考：传什么参数？返回什么值？ 传递的参数：第一个参数是数组，第二个参数是需要查找的元素。 返回值：返回被查找的这个元素的下标。如果找不到返回-1。 */ int index = arraySearch(arr,5); System.out.println(index == -1 ?"该元素不存在":"该元素的下标是："+index); } /** * 从数组中检索某个元素 * @param arr 被检索的数组 * @param element 被检索的元素 * @return 返回大于等于0的数表示元素的下标，-1表示该元素不存在 */ public static int arraySearch(int[] arr, int element) { for(int i = 0 ; i < arr.length;i++){ if(arr[i] == element){ return i; } } return -1; } } -
二分法查找：
第一：二分法查找建立在排序的基础之上。 第二：二分法查找效率要高于“一个挨着一个”的这种查找方式 第三：二分法查找原理 10(下标0) 23 56 89 100 111 222 235 500 600(下标9) arr数组 目标：找出600的下标 (0+9)/2 --------->4 (中间元素的下标) arr[4] 这个元素就是中间元素：arr[4]是100. 100 < 600 说明被查找的元素在100的右边。那么此时开始下标变成：4+1. (5+9) / 2 ---> 7(中间元素的下标) arr[7]对应的是：235 235 < 600 说明被查找的元素在235的右边 开始下标又进行了转变：7 + 1 ( 8 + 9 ) /2 ---> 8 arr[8] ---> 500 500 < 600 开始元素的下标又发生了变化：8+1 (9 + 9) / 2 --->9 arr[9] 是600，正好和600相等，此时找到了。使用二分法进行查找
/* 1、数组工具类：自己写的，不是SUN的。 2、二分法查找算法是基于排序的基础上的(没有排序的数据是无法查找的。) 3、关于查找算法中的：二分法查找 10(下标0) 11 12 13 14 15 16 17 18 19 20(下标10) arr数组 通过二分法查找，找18这个元素的下标： (0 + 10)/2 ------> 中间元素的下标：5 拿着中间这个元素和目标要查找的元素进行对比： 中间元素是：arr[5]--> 15 15 < 18(被查找的元素) 被查找的元素18在目前中间元素15的右边。 所以开始元素的下标从0变成5+1 再重新计算一个中间元素的下标： 开始下标： 5+1 结束下标：10 (6 + 10)/2 --> 8 8下标对应的元素arr[8] 是18 找到的中间元素正好和被查找的元素18相等，表示找到了：下标为8 二分法查找的终止条件：一面折半，直到中间的按个元素恰好是被查找的元素。 第一：二分法查找建立在排序的基础之上。 第二：二分法查找效率要高于“一个挨着一个”的这种查找方式 第三：二分法查找原理 10(下标0) 23 56 89 100 111 222 235 500 600(下标9) arr数组 目标：找出600的下标 (0+9)/2 --------->4 (中间元素的下标) arr[4] 这个元素就是中间元素：arr[4]是100. 100 < 600 说明被查找的元素在100的右边。那么此时开始下标变成：4+1. (5+9) / 2 ---> 7(中间元素的下标) arr[7]对应的是：235 235 < 600 说明被查找的元素在235的右边 开始下标又进行了转变：7 + 1 ( 8 + 9 ) /2 ---> 8 arr[8] ---> 500 500 < 600 开始元素的下标又发生了变化：8+1 (9 + 9) / 2 --->9 arr[9] 是600，正好和600相等，此时找到了。 如果是在前半个里面，则元素下标-1，这个作为终止下标，起始下标不变。 */ public class ArrayUtil { public static void main(String[] args){ int[] arr = {100,200,230,235,600,1000,2000,9999}; //找出arr这个数组中200所在的下标 //调用方法 int index = binarySearch(arr,200); System.out.println(index == -1 ? "该元素不存在":"该元素的下标："+index); } /** * 使用二分法从数组中查找元素的下标 * @param arr 被查找的数组（这个必须是已经排序的） * @param dest 目标元素 * @return */ public static int binarySearch(int[] arr, int dest) { //开始下标 int begin = 0; //结束下标 int end =arr.length-1; //开始元素下标只要在结束元素下标的左边，就一直循环 while(begin <= end){ //中间元素下标 int mid = (begin+end) / 2; if(arr[mid] == dest){ return mid; }else if(arr[mid] < dest){ //目标在中间元素的右边 //起始元素下标 = 中间元素+1 begin = mid + 1 ;//增 }else{ //arr[mid] > dest //目标在“中间”的左边，修改结束元素的下标 end = mid - 1 ;//减 } } return -1; } } -
java.util.Arrays 工具类
所有的方法都是静态的，直接使用类名调用。使用时要文档，不要死记硬背。
主要使用的是两个方法：排序、二分法查找
import java.util.Arrays; /* SUN公司已经为我们程序员写好了一个数组工具类 java.util.Arrays */ public class ArraysText02 { public static void main(String[] args) { //java.util.Arrays; 工具类中有哪些方法，我们开发的时候要参考API帮助文档 int[] arr = {3,6,4,7,12,1,2,32,5,5}; //排序 Arrays.sort(arr); //输出 for (int i = 0; i <arr.length ; i++) { System.out.println(arr[i]); } //二分法查找(建立在排序的基础上) int index = Arrays.binarySearch(arr,511); //输出的index如果是大于等于0的，就存在这个元素，如果小于0，则表示不存在 System.out.println(index < 0 ? "该元素不存在":"该元素下标为：" + index); //如果有两个值是相同的，则碰到哪个就输出哪个元素的下标，跟原理有关。 } }
