Day 11
2019年4月27日。
这是我学习Java的第十一天。
这一天，我学到了以下的知识。
StringBuffer类
StringBuffer，是一个长度可变的字节容器，可以存储多个字符，也可以不断的往容器中追加内容。
构造方法：public StringBuffer() // 无参构造方法
public StringBuffer(int capacity) // 指定容量的字符串缓冲区对象
public StringBuffer(String str) // 指定字符串内容的字符串缓冲区对象
常用的成员方法
- 返回功能
public int capacity()：返回当前容量
- 默认情况下，初始容量为16public int length()：返回长度（字符数）
- 添加功能
public StringBuffer append(String str)：可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区本身public StringBuffer insert(int offset,String str)：在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身
- 删除功能
public StringBuffer deleteCharAt(int index)：删除指定位置的字符，并返回本身public StringBuffer delete(int start,int end)：删除从指定位置开始指定位置结束的内容，并返回本身
- 替换功能
public StringBuffer replace(int start,int end,String str)：从start开始到end用str替换
- 反转功能
public StringBuffer reverse()：字符串反转
- 截取功能
public String substring(int start)：从指定位置截取到末尾public String substring(int start,int end)：截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
StringBuffer和String的相互转换
- String – StringBuffer
- 通过构造方法
- 通过append()方法 - StringBuffer – String
- 使用substring方法
- 通过构造方法
- 通过toString()方法
排序算法
- 冒泡排序
原理：相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
代码如下
public class Test2 {
//冒泡排序：元素两两比较，大的往后放，经过一轮比较后，那么最大的元素就会出现在最后面。
public static void main(String[] args) {
int arr[] = {24, 69, 80, 57, 13};
for (int i = 0; i < arr.length - 1; i++) {
for(int j = 0 ; j < arr.length - i - 1 ; j++){
if (arr[j] > arr[j+1]) {
int tag = arr[j];
arr[j] =arr[j+1];
arr[j+1]= tag;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
- 选择排序
原理：从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
代码如下
public class Test2 {
//选择排序：每次拿一个元素，跟他后面的元素，挨个去比，小的往前放，经过一轮比较后，那么最小元素就会放在最前面去
public static void main(String[] args) {
int arr[] = {24, 69, 80, 57, 13};
for (int index = 0; index < arr.length - 1; index++) {
for(int j = 1 + index; j < arr.length ; j++){
if (arr[index] > arr[j]) {
int tag = arr[index];
arr[index] =arr[j];
arr[j]= tag;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
-
直接插入排序
原理：将后面的元素，插入之前的一个有序列表，使之仍然保持有序代码如下
public class Test2 {
public static void main(String[] args) {
int arr[] = {24, 69, 80, 57, 13};
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0; j--) {
if (arr[j] < arr[j - 1]) {
int tag = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = tag;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
- 希尔排序
原理：对直接插入排序的一种改进，它的思想是选择一个合适的增量，然后经过一轮插入排序后，就会让数组大致有序，然后不断的缩小增量，进行插入排序，直到增量为1，整个排序结束。第一次的增量一般取数组长度的一半
对于增量，具有许多计算方法。其中常见的，就有克努特序列（h=1，h=3*h+1）
代码如下
public class Test2 {
public static void main(String[] args) {
//希尔排序，是对直接插入排序的一种改进，他的思想选择一个合适的增量，然后经过一轮插入排序后，就会让数组大致有序
//然后不断的缩小增量，进行插入排序，直到增量为1 整个排序结束
int arr[] = {24, 69, 80, 57, 13};
shellSort(arr);
//其实我们的直接插入排序，就是增量为1的希尔排序
//int h = 1;
//for (int i = h; i < arr.length; i++) {
// for (int j = i; j > h - 1; j -= h) {
// if (arr[j] < arr[j - h]) {
// swapValue(arr, j, j - h);
// }
// }
//}
System.out.println(Arrays.toString(arr));
}
private static void shellSort(int[] arr) {
//定义增量为4
/* int h=4;
for (int i = h; i < arr.length; i++) {
for (int j = i; j > h - 1; j-=h) {
if (arr[j] < arr[j - h]) {
swapValue(arr, j, j - h);
}
}
}
h = 2;
for (int i = h; i < arr.length; i++) {
for (int j = i; j > h - 1; j -= h) {
if (arr[j] < arr[j - h]) {
swapValue(arr, j, j - h);
}
}
}
h = 1;
for (int i = h; i < arr.length; i++) {
for (int j = i; j > h - 1; j -= h) {
if (arr[j] < arr[j - h]) {
swapValue(arr, j, j - h);
}
}
}*/
//间隔选为4 不是很合理
/* for (int h = 4; h>0; h/=2) {
for (int i = h; i < arr.length; i++) {
for (int j = i; j > h - 1; j -= h) {
if (arr[j] < arr[j - h]) {
swapValue(arr, j, j - h);
}
}
}
}*/
//间隔得选取合理 ：一般第一次的增量我们选取数组长度的一半
/* for (int h = arr.length/2; h > 0; h /= 2) {
for (int i = h; i < arr.length; i++) {
for (int j = i; j > h - 1; j -= h) {
if (arr[j] < arr[j - h]) {
swapValue(arr, j, j - h);
}
}
}
}
*/
//克努特序列
//int h=1;
//h=3*h+1; // 1,4,13,40,121,364
//我要选择一个合适的增量 使用克努特序列来选
int jianGe = 1;
while (jianGe <= arr.length / 3) {
jianGe = 3 * jianGe + 1;
}
for (int h = jianGe; h > 0; h = (h - 1) / 3) {
for (int i = h; i < arr.length; i++) {
for (int j = i; j > h - 1; j -= h) {
if (arr[j] < arr[j - h]) {
int t = arr[j];
arr[j] = arr[j - h];
arr[j - h] = t;
}
}
}
}
}
}
- 合并排序
原理：分而治之，递归
代码如下
public class Test2 {
public static void main(String[] args) {
int arr[] = {24, 69, 80, 57, 13};
//归并排序
//分
chaiFen(arr, 0, arr.length - 1);
//归
// mergerSort(arr,0,(arr.length/2)-1,arr.length-1);
System.out.println(Arrays.toString(arr));
}
private static void chaiFen(int[] arr, int startIndex, int endIndex) {
//计算中间索引
int centerIndex = (startIndex + endIndex) / 2;
//递归来拆
if (startIndex < endIndex) {
//拆分左边
chaiFen(arr, startIndex, centerIndex);
//拆分右边
chaiFen(arr, centerIndex + 1, endIndex);
//归并
mergerSort(arr, startIndex, centerIndex, endIndex);
}
}
/**
* @param arr 要归并的数组
* @param startIndex 起始索引
* @param centerIndex 中间索引
* @param endIndex 结束索引
*/
private static void mergerSort(int[] arr, int startIndex, int centerIndex, int endIndex) {
//定义一个临时数组
int[] tempArray = new int[endIndex - startIndex + 1];
//定义临时数组的起始索引
int index = 0;
//定义左边数组的起始索引
int i = startIndex;
//定义右边数组的起始索引
int j = centerIndex + 1;
//循环比较左右两边数组的元素，往临时数组里面方法
while (i <= centerIndex && j <= endIndex) {
//进来比较
if (arr[i] <= arr[j]) {
tempArray[index] = arr[i];
i++; //记得递增索引
} else {
tempArray[index] = arr[j];
j++;//记得递增索引
}
index++; //临时数组的索引
}
//处理左边剩余元素
while (i <= centerIndex) {
tempArray[index] = arr[i];
i++; //记得递增索引
index++;
}
//处理右边剩余元素
while (j <= endIndex) {
tempArray[index] = arr[j];
j++; //记得递增索引
index++;
}
//这个时候我们的临时数组里面的元素已经排序好了
// System.out.println(Arrays.toString(tempArray));
//遍历临时数组，将临时数组中的元素，放到原数组里面去
for (int k = 0; k < tempArray.length; k++) {
arr[k + startIndex] = tempArray[k];
}
}
}
-
快速排序
原理：先比大小，再分区代码如下
public class Test2 {
public static void main(String[] args) {
int arr[] = {24, 69, 80, 57, 13};
QuickSortUtils.quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
}
class QuickSortUtils {
private QuickSortUtils() {
}
/**
*
* @param arr 要排序的数组
* @param startIndex 开始索引
* @param endIndex 结束索引
*/
public static void quickSort(int[] arr,int startIndex,int endIndex){
if(startIndex<endIndex){
//找到基准数的索引
int index=getIndex(arr,startIndex,endIndex);
//对左右两边进行递归调用
quickSort(arr,startIndex,index);
quickSort(arr,index+1,endIndex);
}
}
//
//将基准数挖出形成第一个坑。
//由后向前找比他小的数，找到后挖出此数填到前一个坑中。
//由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
//再重复执行2，3两步骤。
//挖坑填数
private static int getIndex(int[] arr, int startIndex, int endIndex) {
//定义三个变量
int i=startIndex;
int j=endIndex;
//定义基准数
int x=arr[i];
while (i<j){
//1. 由后向前找比他小的数，找到后挖出此数填到前一个坑中。
while (i<j&&arr[j]>=x){
j--;
}
//填坑
if(i<j){
arr[i]=arr[j];
i++;//顺便让i增一下
}
//2,由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中
while (i<j&&arr[i]<x){
i++;
}
//填坑
if (i < j) {
arr[j] = arr[i];
j--; //顺便让j减一下
}
}
//以上循环完毕之后，将基准数填到最后一个坑里面去
arr[i]=x;
return i;
}
}