我们由简单到复杂来说，我呢就是希望大家也能复习复习，
1.跟换数组元素，前后颠倒
private void setSourt() {
int[] sourt = {5, 6, 4, 8, 7}; int max = sourt.length - 1; int min = 0; int temp; for (min = 0; min < max; min++, max--) {
temp = sourt[min];
sourt[min] = sourt[max];
sourt[max] = temp;
}
sort(sourt);
}2.选择排序
private void setCheck() {
int[] check = {1, 8, 4, 9, 5}; int num; for (int i = 0; i < check.length; i++) { for (int j = i + 1; j < check.length; j++) { if (check[i] < check[j]) {
num = check[i];
check[i] = check[j];
check[j] = num;
}
}
}
sort(check);
}3.冒泡排序
private void setSourSize() {
int[] maopao = {7, 8, 3, 9, 1}; int maoSize; for (int i = 0; i < maopao.length - 1; i++) { for (int j = 0; j < maopao.length - 1 - i; j++) { if (maopao[j] < maopao[j + 1]) {
maoSize = maopao[j];
maopao[j] = maopao[j + 1];
maopao[j + 1] = maoSize;
}
}
}
sort(maopao);
}4.折半查找
public static int binarySearch(int[] arr, int key) {
//定义三个指针变量
int min = 0; int max = arr.length - 1; int mid = 0; //循环折半,条件 min<=max
while (min <= max) { //公式,计算中间索引
mid = (min + max) / 2; //让被找元素,和中间索引元素进行比较
if (key > arr[mid]) {
min = mid + 1;
} else if (key < arr[mid]) {
max = mid - 1;
} else { //找到元素,返回元素索引
return mid;
}
} return -1;
}5.后面这几个是俩个案例
/**
* 给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
* <p>
* 你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
*/private int[] setSumm() { int[] arr = {1, 3, 5, 7, 9, 11, 15}; int key = 6; for (int i = 0; i < arr.length; i++) { for (int j = i + 1; j < arr.length; j++) { int nu = arr[i] + arr[j]; if (nu == key) {
List<Integer> list = new ArrayList<>(); list.add(arr[i]); list.add(arr[j]); int[] num = new int[list.size()]; for (int k = 0; k < list.size(); k++) {
num[k] = list.get(k);
} return num;
}
}
} return null;
}/**
* 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
* 输出：7 -> 0 -> 8
* 原因：342 + 465 = 807
*/private void setJia() { int[]ints={1,5,8}; int[]num={2,8,5};
List<Integer>listInter=new ArrayList<>();
List<Integer>integers=new ArrayList<>(); for (int i = ints.length-1; i>=0; i--) {
listInter.add(ints[i]);
} for (int j = num.length-1; j >=0; j--) {
integers.add(num[j]);
}
StringBuilder stringBuilder=new StringBuilder();
String b; for (int i = 0; i < listInter.size(); i++) {
stringBuilder.append(listInter.get(i));
}
b=stringBuilder.toString().toLowerCase(); int one=Integer.valueOf(b);
System.out.println(one);
StringBuilder builder=new StringBuilder();
String c; for (int i = 0; i < integers.size(); i++) {
builder.append(integers.get(i));
}
c=builder.toString().toLowerCase(); int two=Integer.valueOf(c);
System.out.println(two); int three=one+two;
List<String>fourList=new ArrayList<>();
String threeString=String.valueOf(three); for (int i = threeString.length()-1; i >=0; i--) {
System.out.println(threeString.charAt(i)+"可以得");
fourList.add(String.valueOf(threeString.charAt(i)));
} for (int i = 0; i < fourList.size(); i++) {
System.out.println(fourList.get(i));
}
}最后我说一个东西，第三方隔离，这个在我们现实中用的比较多，大家可以了解这个东西，我们跟换我们项目网络框架发现，很繁琐，后来我就把他弄成这种思想，当我们能一遍遍优化自己代码的时候
那么我们就离架构师不远了，当你你可以把自己项目推了重新构建的勇气的时候，那么你可能就到架构师的层次，每越过一座山的时候你就感觉爽了。
随时随地看视频
