StringBuffer和一些算法 冒泡 二分 选择

package 复习;


import javax.swing.text.Utilities;


import day14.UtilArray;


/**
 * method: 1.大的字母换小的 ，小的换大的 返回一个新字符串 2. 判断一个字符串是否是回文就是对称数，从左往右读和从右往左读都一样。例如
 * abcba aba 要求字符串长度必须是奇数，不能少于3个字符 3.字符串的反转 4.冒泡 5.选择 6.二分查找 7.数组[]用字符串String的方法
 * 8.数组[] 用字符缓存append法 9.判断一个字符串在另一个字符串里的次数并计数 10. *
 * 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符) 11.* 缓冲区->String->char[] 数组反转 ->
 * 缓冲区
 * 
 * 
 */
public class javaStringandBufferMethod {


public static void main(String[] args) {
int[] arr = { 1, 2, 3, 6, 5, 4, 8 };
String s1 = "safasDA123df";
// String method1 = method1(s1);
// System.out.println(method1);
//
// boolean method2 = method2(s1);
// System.out.println(method2);
//
// String method3 = method3(s1);
// System.out.println(method3);
// mehtod4(arr);


// method5(arr);


// int index = method6(arr,6);
// System.out.println(index);
// 数组[]用字符串String的方法
// method7(arr);
// 8.数组[] 用字符缓存append法
method8(arr);
// 9.判断一个字符串在另一个字符串里的次数并计数
method9(s1, "s");
// 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
method10(s1);


// 11.* 缓冲区->String->char[] 数组反转 ->
StringBuilder builder=new StringBuilder();
builder.append("asdfsa");
method10(builder);


}

// .* 传递进来的是缓冲区->String->char[] 数组反转 ->
// * 缓冲区
private static StringBuilder method10(StringBuilder builder) {
char[] array = builder.toString().toCharArray();
//遍历数组,反转数组
for(int min=0,max=array.length;max>min;min++,max--){
char temp=array[min];
array[min]=array[max];
array[max]=temp;
}

//将缓冲区中已有的字符清空
//buffer.delete(0, buffer.length());
//将数组变成缓冲区返回
return builder.delete(0, builder.length()).append(array);


}
// 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数
private static void method10(String s1) {
int upper = 0;
int lower = 0;
int number = 0;
char[] array = s1.toCharArray();
for (int i = 0; i <= array.length-1; i++) {
// 每次一循环，我们就判断他是数字还是字母，我们用局部变量俩赋值，相当于一个容器给计数器来记录下次数
if (Character.isUpperCase(array[i])) {
upper++;
}
if(Character.isLowerCase(array[i])){
lower++;
}
if(Character.isDigit(array[i])){
//如果他要是数字
number++;
}


}
System.out.println(upper);
System.out.println(number);
System.out.println(lower);

}


private static void method9(String s1, String s2) {
int count = 0;
int index = 0;
// 如果s2字符串在s1字符串里找不到就返回-1
while ((index = s1.indexOf(s2)) != -1) {// 一直循环直到找不到s2，在s1里
// 如果找到了计数器+1
count++;


// 把找到的字符串的剩下的字符串给从新赋予给s1
s1 = s1.substring(index + s2.length());
}
System.out.println(count);


}


/*
* 定义方法,实现数组的字符串拼接 不能使用String的+操作 StringBuffer的append 节约内存 传递数组,获取拼接后的返回值
*/
private static void method8(int[] arr) {
// 定义一个缓冲字符串
StringBuilder s = new StringBuilder();
// 给容器中添加一个[括号
s.append("[");
// 循环判断位置来添加 ,数或是]
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1) {
s.append(arr[i] + ",");
} else {
s.append(arr[i] + "]");
}
}
// 把容器里的东西给打印出来
System.out.println(s);
}


// 数组[]用字符串String的方法


private static void method7(int[] arr) {
// 定义一个变量s初始值为[
String s = "[";
// 循环判断位置来添加 ,数或是]
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1) {
// 第一个进来s=[ 给加上 第一索引下标数和一个, 把他们3给赋值给s
// 第二次进 s就已经是[1,了；循环下去
s = s + arr[i] + ",";
} else {
s = s + arr[i] + "]";
}
}
System.out.println(s);


}


// 二分查找，必须 有序数组
private static int method6(int[] arr, int key) {
// 定义3个变量
int min = 0;
int max = arr.length - 1;
int mid = 0;
// 如果小的下标要是大于等于大的下标索引我们就继续循环
while (min <= max) {
// 中间索引是小加大索引除以2
mid = (min + max) / 2;
// 如果中间值小于用户要查找的值 ，他肯定是在大的右边 ，数组里
if (arr[mid] < key) {
// 那么小的索引坐标就变成中间值加1，我们从大的右边开始从新循环
min = mid + 1;
} else if (arr[mid] > key) {
max = mid - 1;
} else {
return mid;
}
}
return -1;


}


// 选择排序，让数组0索引坐标，和每一个值来比较，把最小放到最前面
private static void method5(int[] arr) {


for (int i = 0; i < arr.length; i++) {
// 内循环是外循环加1
for (int j = i + 1; j < arr.length; j++) {
// 如果第一个值小于第二个就交互位置，内循环一直循环直到保证第一个索引坐标是最小的了，就开始外层循环开始把第二坐标变成最小
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}


for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i] + " ");
}
}


// 冒泡排序，两两比较，每次内循环一圈，冒泡最上面都减少一层
private static void mehtod4(int[] arr) {


for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}


for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}


}


// 字符串的反转 返回一新的字符串
private static String method3(String s1) {
char[] s2 = s1.toCharArray();


for (int min = 0, max = s2.length - 1; min < max; min++, max--) {
char temp = s2[min];
s2[min] = s2[max];
s2[max] = temp;
}


return new String(s2);
}


// 字符串小写变大写，大写变小写，返回一个新的字符串
private static String method1(String s1) {
char[] charArray = s1.toCharArray();
for (int i = 0; i <= charArray.length - 1; i++) {


if (charArray[i] >= 65 && charArray[i] <= 90) {
charArray[i] += 32;
} else if (charArray[i] >= 97 && charArray[i] <= 122) {
charArray[i] -= 32;
}


}
return new String(charArray);
}


private static boolean method2(String s1) {
if (s1.length() % 2 == 0 || s1.length() < 3) {
return false;
}
char[] charArray = s1.toCharArray();
for (int min = 0, max = s1.length() - 1; min < max; min++, max--) {
if (charArray[min] != charArray[max]) {
// 我自己写的时候是== 然后给的true，结果asfda也给的true就是错误了
// 正确结果是现在这样，我怎么忘了老师说的，在做逻辑判断是时候，先给出非法的条件
return false;
}


}


return true;
}


}