画图演示
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
需求： 数组元素：{24, 69, 80, 57, 13} 请对数组元素进行排序。
package com.heima.array; public class Demo1_Array { /** 数组元素：{24, 69, 80, 57, 13} 请对数组元素进行排序。 冒泡排序 相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处 */ public static void main(String[] args) { int[] arr = {24, 69, 80, 57, 13}; bubbleSort(arr); print(arr); } public static void bubbleSort(int[] arr) { for(int i = 0; i < arr.length -1 ; i++) { // 外循环只需要比较arr.length-1次就行了 for(int j = 0; j < arr.length - i - 1; j++) { // -1 是为了防止索引越界异常,-i 是为了 if(arr[j] > arr[j + 1]) { int tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } } public static void print(int[] arr) { for(int i = 0;i < arr.length; i++){ System.out.print(arr[i] + " "); } } }
画图演示
需求：
数组元素：{24, 69, 80, 57, 13}
请对数组元素进行排序。
选择排序
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
数组高级选择排序代码实现
package com.heima.array; public class Demo1_Array { /** 每轮固定首位，一轮下来获取最小值在首位 */ public static void main(String[] args) { int[] arr = {24, 69, 80, 57, 13}; selectSort(arr); print(arr); } public static void print(int[] arr) { for(int i = 0;i < arr.length; i++){ System.out.print(arr[i] + " "); } } 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++) { // -1 是为了防止索引越界异常 if(arr[i] > arr[j]) { int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; } } } } }
画图演示
二分查找
前提：数组元素有序
数组高级二分查找代码
package com.heima.array; public class Demo2_Array { /** 数组高级二分查找 */ public static void main(String[] args) { int[] arr = {11,22,33,44,55,66,77}; System.out.println(getIndex(arr, 22)); System.out.println(getIndex(arr, 88)); System.out.println(getIndex(arr, 10)); } /* * 二分查找 * 返回值类型：int（索引位置） * 参数列表：int[] arr,int value */ public static int getIndex(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) { // 当中间值小于要找的值 min = mid + 1; // 最小的索引改变 } else if(arr[mid] > value){ // 当中间值大于要找的值 max = mid - 1; // 最大的索引改变 } mid = (min + max) / 2; // 无论最大还是最小改变，都要重新更新中间索引 if(min > max) { // 如果最小索引大于最大索引，就没有找到的可能性了 return -1; } } return mid; } }
注意事项
如果数组无序，就不能使用二分查找。
因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。
Arrays类概述
针对数组进行操作的工具类。
提供了排序，查找等功能。
成员方法
public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)
package com.heima.array; import java.util.Arrays; public class Demo3_Arrays { /** public static String toString(int[] a) public static void sort(int[] a) public static int binarySearch(int[] a,int key) */ 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)); System.out.println(Arrays.binarySearch(arr, 44)); //二分查找 System.out.println(Arrays.binarySearch(arr, 77)); } }
为什么会有基本类型包装类
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
常用操作
常用的操作之一：用于基本数据类型与字符串之间的转换。
基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Integer类概述
Integer 类在对象中包装了一个基本类型 int 的值。
该类提供了多个方法，能在 int 类型和 String 类型之间互相转换。
还提供了处理 int 类型时非常有用的其他一些常量和方法
构造方法
public Integer(int value)
public Integer(String s)
案例演示
使用构造方法创建对象
package com.heima.wrapclass; public class Demo1_Integer { /** * @param args */ public static void main(String[] args) { Integer i = new Integer(10); System.out.println(i); Integer j = new Integer("100"); System.out.println(j); System.out.println(Integer.MAX_VALUE); System.out.println(Integer.MIN_VALUE); } }
int --> String
将int值和""进行拼接
public static String valueOf(int i)
int -- Integer -- String，先生成Integer对象，再调用toString方法
直接使用Integer的toString的静态方法：public static String toString(int i)(Integer类的静态方法)
String --> int
String -- Integer -- int
public static int parseInt(String s)
package com.heima.wrapclass; public class Demo2_Integer { /** * @param args */ public static void main(String[] args) { int i = 10; int2String(i); String s = "11"; string2Int(s); } public static void int2String(int i) { // 第一种，通过"" 拼接变成字符串。 推荐用 System.out.println(i + ""); // 第二种，通过String类的 valueOf方法。 推荐用 System.out.println(String.valueOf(i)); // 第三种：通过Integer包装类中的toString()方法 //int -- Integer -- String(Integer类的toString方法()) System.out.println(Integer.toString(i)); } public static void string2Int(String s) { // 第一种：通过将String转换成Integer对象，得到int // String -- Integer -- int Integer i = new Integer(s); System.out.println(i.intValue()); // 第二种：推荐 // public static int parseInt(String s) 将字符串参数作为有符号的十进制整数进行解析。 System.out.println(Integer.parseInt(s)); } }
JDK5的新特性
自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
案例演示
JDK5的新特性自动装箱和拆箱
Integer ii = 100;
ii += 200;
package com.heima.wrapclass; public class Demo3_JDK5 { public static void main(String[] args) { // 手动装箱 int x = 100; Integer i1 = new Integer(x); // 自动装箱 Integer i2 = 100; System.out.println(i2); //手动拆箱 int y = i2.intValue(); System.out.println(y); // 自动拆箱 int z = i1 + 200; System.out.println(z); } }
注意事项
在使用时，Integer x = null；底层x调用intValue，但是x是null，null调用方法就会出现 NullPointerException（空指针异常）。
建议先判断是否为null，然后再使用。
package com.heima.wrapclass; public class Demo3_JDK5 { public static void main(String[] args) { Integer i = null; int y = i + 100; } }
Integer的面试题
看程序写结果
package com.heima.wrapclass; import java.lang.Integer.IntegerCache; public class Demo4_Integer { 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)); // 输出true /* * i1 == i2, 比较地址值是否相同 * * * i1.equals * 比较此对象与指定对象。 * 当且仅当参数不为null，并且是一个与该对象包含相同int值的Integer对象时，结果为true */ 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 = 97; Integer i6 = 97; System.out.println(i5 == i6); // 输出 true。 System.out.println(i5.equals(i6)); // 输出true Integer i7 = 197; Integer i8 = 197; System.out.println(i7 == i8); // 输出 false System.out.println(i7.equals(i8)); // 输出true /* * -128到127是byte的取值范围，如果在这个取值范围内，自动装箱就不会创建新对象，而是从常量池中获取 * 如果超过了byte取值范围，就会再创建对象 * * public static Integer valueOf(int i) { assert IntegerCache.high >= 127; if (i >= IntegerCache.low && i <= IntegerCache.high) //i>=-128 && i<127 return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); // 不在[-128,127]区间范围内，就直接重新创建Integer对象 } * * * */ } }
原文：https://www.cnblogs.com/zoe233/p/12841012.html
