1.冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处（当然也可以根据要求把最小值放最后），第二次比较后，最大值放在了倒数第二的位置，一直到第二个元素确定了，整个数组的顺序也就确定了冒泡排序的外层循环是需要确定位置的数的个数，换句话说，也就是有几个数需要确定位置，它的值是数组元素数少1，如果元素为5个的话，则需要确定四个数的位置，第五个数就已经定下来了，整个数组的顺序就被确定了，这里取最大值还是最小值完全是看业务逻辑，都能完成
数组冒泡排序的原理图：
从原理图上看，每确定一个位置，其间都需要数次比较，这和打印99乘法口诀表非常像，每打印一行，期间需要打印多次，也像一栋楼的不同楼层，每层楼有多个房间。
一定是循环的嵌套。
2.选择排序
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
外层循环控制的是总共需要确定位置的数的次数，比如有五个数，那么只需要确定四个数的位置即可，从小到大排序
外层循环第一次，确定的是第一个位置上的数：
第一次拿第一个元素和第二个元素比，如果比它小，则交换；
第二次拿第一个元素和第三个元素比，如果比它小，则交换；
...
直到第一个数和最后一个数比完，得出的结果就是第一个位置上的数是所有数中的最小值
外层循环第二次，确定的是第二个位置上的数：
第一次拿第二个位置上的数和第三个位置上的数比，比它小，则交换；
第二次拿第二个位置上的数和第四个位置上的数比，比它小，则交换；
...
直到第二个数和最后一个数比完，得出的结果就是第二个位置上的数是剩余数中的最小值
外层循环N-1次，得出的结果就是最小值在前
3.二分查找（折半查找）
二分查找的前提是数组已经是有序的了，（升序或者降序都可以，只不过在判断中要根据逻辑做更改），否则不会得到正确结果
/*
* 查找：
* 基本查找:数组元素无序(从头找到尾)
* 二分查找(折半查找):数组元素有序
*
* 分析：
* A:定义最大索引，最小索引
* B:计算出中间索引
* C:拿中间索引的值和要查找的值进行比较
* 相等：就返回当前的中间索引
* 不相等：
* 大 左边找
* 小 右边找
* D:重新计算出中间索引
* 大 左边找
* max = mid - 1;
* 小 右边找
* min = mid + 1;
* E:回到B
*/
public class ArrayDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {11,22,33,44,55,66,77};
//写功能实现
int index = getIndex(arr, 33);
System.out.println("index:"+index);
//假如这个元素不存在后有什么现象呢?
index = getIndex(arr, 333);
System.out.println("index:"+index);
}
public static int getIndex(int[] arr,int value){
//定义最大索引，最小索引
int max = arr.length -1;
int min = 0;
//计算出中间索引
int mid = (max +min)/2;
//由于不知道比较多少次，所以用无限循环
//如果和中间值相等，直接返回中间值索引，否则判断是在左边还是右边
//重新计算中间索引，当索引值超出正常范围，直接返回-1，表明没有找到，否则循环继续
while (true) {
if (arr[mid] == value) {
return mid;
} else {
if (arr[mid] > value) {
max = mid - 1;
} else {
min = mid + 1;
}
if(min > max){
return -1;
}
mid = (min + max) / 2;
}
}
//下面写法做了些改进，稍微简洁一些
//拿中间索引的值和要查找的值进行比较，如果不等，进入循环，如果相等，直接返回
while(arr[mid] != value){
if(arr[mid]>value){
max = mid - 1;
}else if(arr[mid]<value){
min = mid + 1;
}
if(min > max){
return -1;
}
mid = (max +min)/2;
}
return mid;
}
}
5.Arrays类概述
系统提供的针对数组进行操作的工具类。
提供了排序，查找等功能。不用我们手动去写算法，直接拿来就用
静态方法
- public static String toString(int[] a)：将数组转换成字符串
- public static void sort(int[] a)：对一个int数组进行升序排序ascending
- public static int binarySearch(int[] a,int key)：在数组中进行二分查找
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
// 定义一个数组
int[] arr = { 24, 69, 80, 57, 13 };
//把数组转成字符串
System.out.println("排序前：" + Arrays.toString(arr));
// 对数组进行排序
Arrays.sort(arr);
System.out.println("排序后：" + Arrays.toString(arr));
// [13, 24, 57, 69, 80]
//在进行二分查找之前，要保证数组已经是排好序的，否则不能保证结果
System.out.println("binarySearch:" +
Arrays.binarySearch(arr, 57));
System.out.println("binarySearch:" +
Arrays.binarySearch(arr, 577));
}
}
6.基本类型包装类概述
基本数据类型的包装类，就是把基本数据类型的值再进行一次包装，封装成一个类，其中包含一些静态和非静态方法。
其好处在于可以在类中定义更多的功能方法操作该数据。
常用的操作之一：用于基本数据类型与字符串之间的转换。
字符串转int
字符串转double
7.基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Integer，Character名称上有些变化，其余类名都是把基本数据类型的类型首字母大写
查看API文档
/*
* 用于基本数据类型与字符串之间的转换。
使用的是Integer包装类的静态方法，对整型数进行操作
*/
public class IntegerDemo {
public static void main(String[] args) {
// public static String toBinaryString(int i)
System.out.println(Integer.toBinaryString(100));
// public static String toOctalString(int i)
System.out.println(Integer.toOctalString(100));
// public static String toHexString(int i)
System.out.println(Integer.toHexString(100));
// public static final int MAX_VALUE
System.out.println(Integer.MAX_VALUE);
// public static final int MIN_VALUE
System.out.println(Integer.MIN_VALUE);
}
}
8.Integer类概述及其构造方法
Integer类概述
Integer 类在对象中包装了一个基本类型 int 的值
该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法
构造方法
- public Integer(int value)：通过一个int值构造一个Integer对象
- public Integer(String s)：通过一个字符串构造一个Integer对象
/*
* 注意：这个字符串必须是由数字字符组成
*/
public class IntegerDemo {
public static void main(String[] args) {
// 方式1，将int型当参数传入构造
int i = 100;
Integer ii = new Integer(i);
System.out.println("ii:" + ii);
// 方式2 ，用一个全是数字的字符串构造包装类对象
String s = "100";
// String s = "abc";// NumberFormatException
Integer iii = new Integer(s);
System.out.println("iii:" + iii);
}
}