常见对象·Arrays 类和 包装类
数组高级冒泡排序原理图解
* A：画图演示
* 需求：
数组元素：{24, 69, 80, 57, 13}
请对数组元素进行排序
* 冒泡排序：
相邻元素两两比较，较大的往后放，第一次完毕，最大值出现在了最大索引处
数组高级冒泡排序代码实现
* A：案例演示
* 数组高级冒泡排序代码
package com.heima.array; public class Demo1_Array { public static void main(String[] args) { int[] arr = { 24, 69, 80, 57, 13 }; bubbleSort(arr); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } } /* * 冒泡排序： * 1、返回值类型，void * 2、参数列表，int[] arr */ public static void bubbleSort(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { // 外循环：只需要比较arr.lenth-1次就行了 for (int j = 0; j < arr.length - i - 1; j++) { // 减一防止索引越界，-i并且提高效率 if (arr[j] > arr[j + 1]) { int tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } } }
数组高级选择排序原理图解
* A：画图演示
* 需求：
* 数组元素：{24, 68, 80, 57, 13}
* 请对数组元素进行排序
*选择排序
* 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕时，最小值出现在了最小索引处
数组高级选择排序代码实现
* A：案例演示
* 数组高级选择排序代码
package com.heima.array; public class Demo2_Array { public static void main(String[] args) { int[] arr = { 13, 69, 80, 57, 24 }; selectSort(arr); print(arr); } /* * 如果某个方法只针对本类使用，不想让其他类试图用就可以定义成私有的 */ public static void print(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } /* * 选择排序： 1、返回值void 2、参数列表int[] arr */ public static void selectSort(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { // 只需要比较arr.length-1次 for (int j = i + 1; j < arr.length; j++) { if (arr[i] > arr[j]) { swap(arr, i, j); } } } } /* * 换位操作： 1、返回值类型，void 2、参数列表int[] arr, int i, int j */ public static void swap(int[] arr, int i, int j) { int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; } }
数组高级二分查找原理图解
* A：画图演示
* 二分查找，查找元素所对应的索引
* 前提，数组元素有序
数组高级二分查找代码实现及注意事项
* A：案例演示
* 数组高级二分查找代码
* B：注意事项
* 如果数组无序，就不能使用二分查找
* 原因：因为如果你排序了，但是你排序的时候就已经改变了数组的原始索引
package com.heima.array; import java.util.Scanner; public class Demo3_Array { public static void main(String[] args) { int[] arr = { 11, 22, 33, 44, 55, 66, 77 }; Scanner sc = new Scanner(System.in); int i = sc.nextInt(); int p = binarySearch(arr, i); System.out.println(p); } /* * 二分查找： 1、返回值类型，int * 2、参数列表 int[] arr, int value */ private static int binarySearch(int[] arr, int value) { int min = 0; int max = arr.length - 1; int mid = (min + max) / 2; while (arr[mid] != value) { // 当中间值不等于要找的值，就开始循环查找 if (arr[mid] > value) { // 当中间值大于要找的值，改变最大值 max = mid - 1; } else if (arr[mid] < value) { // 当中间值小于要找的值，就改变最小值 min = mid + 1; } mid = (min + max) / 2; // 无论最大还是最小，中间索引都会随之改变 if (min > max) { // 如果最小索引大于最大索引，则表面要找的值不存在 return -1; } } return -(min + 1); } }
Arrays类的概述和方法使用
* A：Arrays类概述
* 针对数组进行操作的工具类
* 提供了排序、查找等功能
* B：成员方法
* public static String toString(int[ ] arr)
* public static void sort(int[] arr)
* public static int binarySearch(int[ ] a, int key)
public static String toString(int[] a) { if (a == null) return "null"; int iMax = a.length - 1; if (iMax == -1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }
private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) { int low = fromIndex; int high = toIndex - 1; while (low <= high) { int mid = (low + high) >>> 1; int midVal = a[mid]; if (midVal < key) low = mid + 1; else if (midVal > key) high = mid - 1; else return mid; // key found } return -(low + 1); // key not found. }
package com.heima.array; import java.util.Arrays; public class Demo4_Array { public static void main(String[] args) { int[] arr = { 33, 22, 11, 44, 66, 55 }; System.out.println(Arrays.toString(arr)); // 将数组变成字符串 Arrays.sort(arr); System.out.println(Arrays.toString(arr)); // 对数组进行排序 int[] arr2 = { 11, 22, 33, 44, 55, 66, 77 }; // 二分查找的对象必须是有序的数组，如果数组中包含多个重复的值，则无法保证找到的是哪一个 System.out.println(Arrays.binarySearch(arr2, 12)); // 如果要找的值包含在数组中，则返回其索引；否则返回（-（插入点）-1） } }
基本数据类型包装类的概述
* A：为什么会有基本类型的包装类
* 好处在于可以在对象中定义更多的功能方法来操作该数据
* B：常用操作
* 用于基本数据类型与字符串之间的转换
* C：基本类型和包装类的对应关系
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
package com.heima.wrapclass; public class Demo1_Integer { public static void main(String[] args) { System.out.println(Integer.toBinaryString(60)); // 二进制输出 System.out.println(Integer.toOctalString(60)); // 八进制输出 System.out.println(Integer.toHexString(60)); // 十六进制输出 } }
Integer类的概述和构造方法
* A：Integer类的概述
* 通过JDK提供的API，查看Integer类 的说明
* Integer类 在对象中包装了一个基本类型 int 的值
* 该类提供了多个方法，能在 int 类型和 String 类型之间相互转换
* 还提供了处理 int 类型时非常有用的其他一些常量和方法
* B：构造方法
* public Integer(int value)
* public Integer(String str)
* C：案例演示
* 使用构造方法创建对象
package com.heima.wrapclass; public class Demo2_Integer { public static void main(String[] args) { System.out.println(Integer.MAX_VALUE); // Integer能表示的最大数 System.out.println(Integer.MIN_VALUE); // Integer能表示的最小数 // Integer构造方法 Integer i1 = new Integer(100); System.out.println(i1); // Integer i2 = new Integer("abc"); // 数字格式异常： java.lang.NumberFormatException Integer i2 = new Integer("100"); System.out.println(i2); } }
String 和 int 类型的相互转换
* A：int -> String
* a：和 "" 进行拼接
* b：public static String valueOf(int i)
* c：int -> Integer -> String (调用 Integer类 的 toString方法)
* d：public static String toString(int i) (Integer类的静态方法)
* B：String -> int
* a：String -> Integer -> int
* public staticint parseInt(String s)
package com.heima.wrapclass; public class Demo3_Integer { public static void main(String[] args) { // demo1(); // int -> String // demo2(); // String -> int String s1 = "true"; boolean b = Boolean.parseBoolean(s1); System.out.println(b); //String s2 = "abc"; //char c = Character.parse // char的包装类Character中没有parseXxx的方法 // 字符串到字符的转换通过toCharArray() 就可以把字符串转换为字符数组 } public static void demo2() { String s = "200"; Integer i3 = new Integer(s); int i4 = i3.intValue();// string转换成integer 再转换成int System.out.println(i4); int i5 = Integer.parseInt(s);// 直接将string转换成int，推荐使用 System.out.println(i5); /* * 基本数据类型的包装类又八种 * 其中七种都有parseXxx的方法，可以将七种类型转换成基本数据类型，char类型没有 * 字符串到字符的转换通过toCharArray方法就行 */ } public static void demo1() { int i = 100; String s1 = i + ""; System.out.println(s1); // 将数字和""相加,推荐使用 String s2 = String.valueOf(i); System.out.println(s2); // 调用valueof方法 Integer i2 = new Integer(i); String s3 = i2.toString(); System.out.println(s3); // 将int转换为integer再调用toString方法 String s4 = Integer.toString(i); System.out.println(s4); // 直接调用integer类 } }
JDk5新特性自动装箱和自动拆箱
* A：JDK5的新特性
* 自动装箱：把基本类型转换为包装类类型
* 自动拆箱：把包装类类型转换为基本类型
* B：案例演示
* JDK5的新特性自动装箱和拆箱
* Integer i = 100;
* i += 100;
* C：注意事项
* 在使用时，Integer x = null; 代码就会出现NullPointerException
* 建议先判断为否为null，然后再使用
package com.heima.wrapclass; public class Demo4_JDK5 { public static void main(String[] args) { int x = 100; Integer i1 = new Integer(x);// 将基本数据类型包装成对象，手动装箱 int y = i1.intValue(); // 将对象转换成基本数据类型，手动拆箱 Integer i2 = 100;// 自动装箱，把基本数据类型 转换成 引用数据类型 int z = i2 + 200;// 自动拆箱，把引用数据类型 转换为 基本数据类型 System.out.println(z); // Integer i3 = null; // int a = i3 + 100; // 底层调用intValue，但是i3是null，会出现空指针异常：java.lang.NullPointerException // System.out.println(a); } }
Integer 的面试题
* A：Integer 的面试题
* 看程序写结果
package com.heima.wrapclass; public class Demo5_Integer { /** * @param args */ public static void main(String[] args) { Integer i1 = new Integer(97); Integer i2 = new Integer(97); System.out.println(i1 == i2); // 判断地址值，false System.out.println(i1.equals(i2)); // Integer类以重写equals方法，true System.out.println("---------------------"); Integer i3 = new Integer(197); Integer i4 = new Integer(197); System.out.println(i3 == i4); // false System.out.println(i3.equals(i4)); // true System.out.println("----------------------"); Integer i5 = 127; Integer i6 = 127; System.out.println(i5 == i6); // true,i5和i6指向了同一对象 System.out.println(i5.equals(i6)); //true System.out.println("----------------------"); Integer i7 = 128; Integer i8 = 128; System.out.println(i7 == i8); // false System.out.println(i7.equals(i8)); // true /* * -128到127是byte的取值范围， * 如果在这个取值范围内，自动装箱就不会创建新对象，而是从常量池中获取 * 如果超过了byte的取值范围，就会再新创建对象 */ } }