作业题
例题一：
案例演示:
需求：把字符串反转
举例：键盘录入 “abc”
反转结果：“cba”
public class MyTest2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一段字符串");
String s = scanner.nextLine();
String str="";
for (int length = s.length()-1; length >= 0; length--) {
char ch = s.charAt(length);
str+=ch;
}
System.out.println(str);
}
}
例题二：
案例演示
需求：把数组中的数据按照指定个格式拼接成一个字符串
举例：
int[] arr = {1, 2, 3};
拼接结果：
“[1, 2, 3]”*/
public class MyTest {
public static void main(String[] args) {
int[] arr = {1, 2, 3,4,5};
//"[1, 2, 3]"
String str="[";
for (int i = 0; i < arr.length; i++) {
// System.out.println(arr[i]);
if(i==arr.length-1){
str += arr[i]+"]";
}else{
str += arr[i]+",";
}
}
System.out.println(str);
}
}
例题三：
画图演示
需求：统计大串中小串出现的次数
举例:
"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”中java出现了5次*/
//方法一
public class MyTest3 {
public static void main(String[] args) {
String maxStr = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
String minStr = "java";
int index = maxStr.indexOf(minStr);
//定义一个统计变量
int count = 0;
while (index != -1) {
count++;
maxStr = maxStr.substring(index + 4);
//再次查找重新赋值索引
index = maxStr.indexOf(minStr);
}
System.out.println("java 出现了 "+count+" 次");
}
}
//方法二
public class MyTest4 {
public static void main(String[] args) {
String maxStr = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
String minStr = "java";
int count = 0;
if (!maxStr.contains("*")) {
String s = maxStr.replace(minStr, "*");
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
if(ch=='*'){
count++;
}
}
}
System.out.println(count);
}
}
//方法三
public class MyTest5 {
public static void main(String[] args) {
String maxStr = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
String minStr = "java";
int length = maxStr.length();
int length1 = maxStr.replace(minStr, "").length();
System.out.println((length - length1) / 4);
}
}
字符串缓冲区
例一：
String str="abc"// abc
str+="ccc";// ccc//abcccc
str+="ddd;//ddd//abcccddd
构建了5个字符串缓冲区
例二：
String str="abc"+"abcccc"+"abcccddd"
总共构建了一个字符串缓冲区
StringBuffer:
线程安全的可变字符序列，相当于一个字符容器，你可以不不断的往容器中追加。
创建一个空的字符容器:
StringBuffer sb = new StringBuffer( );
往容器中追加数据:
sb.append("abcaaaaaaaaaaaaa");
StringBuffer( ):一个其中不带字符的字符串缓冲区，初始容量为16个字符。
容量：
int capacity = sb.capacity( );
System.out.println(capacity);
长度：
int length = sb.length( );
System.out.println(length);
//构建时，可以指定这个字符容器的容量
StringBuffer sb = new StringBuffer(100);
System.out.println(sb.capacity());//结果为100
//构建容器时，可以往容器中放入字符串
StringBuffer sb2= new StringBuffer("abbcdfdfd");
//StringBuffer 线程安全的可变字符序列。相当于一个字符容器，你可以不断的往容器中追加字符。
链式编程：
public class MyTest {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//append("abc"); 往容器中追加数据，返回的还是原来的那个容器对象。
StringBuffer sb2 = sb.append("abc");
System.out.println(sb==sb2);//true
sb.append(100).append(200).append(true).append(new char[]{'a','b','c'});
//StringBuffer 重写了toString()方法，然后把容器中的数据转换成字符串返回
System.out.println(sb.toString());//"abc100200trueabc"
}
}
#### append（）
往容器中追加数据，然后返回的还是原来的。
即新定义的对象和原来的对象输出的时候结果是相同的。
StringBuffer重写了toString（）方法,然后把容器中的数据转换成字符串放回
package.java.sort;
public class buff {
public static void main(String[] args) {
StringBuffer bu=new StringBuffer();
StringBuffer sb2=bu.append("ABC");
System.out.println(bu==sb2);
//sb2就是原来的bu
sb.append(100).append(200).append(true).append(new char[]{'a','b','c'});
//StringBuffer 重写了toString()方法，然后把容器中的数据转换成字符串返回
System.out.println(sb.toString());//"abc100200trueabc"
}
}
运行结果：
true
ABC100200trueabc
Process finished with exit code 0
例题二：
案例演示
需求：用StringBuffer的功能实现，把数组中的数据按照指定个格式拼接成一个字符串
举例：
int[] arr = {1, 2, 3};
输出结果： “[1, 2, 3]”
public class MyTest2 {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
StringBuffer sb = new StringBuffer("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
sb.append(arr[i]).append("]");
}else{
sb.append(arr[i]).append(",");
}
}
String s = sb.toString();
System.out.println(s);
}
}
排序总结
**数组排序：**把数组中的无序的元素，通过交换移动等方式，使数组中的元素，成为一个有序序列。通过冒泡排序，排序数组。
快捷键：ctrl+alt+M 抽取方法。
冒泡排序
冒泡排序: 数组中的元素两两比较，大的元素往后放，经过一轮比较后，最大的元素会出现在最后面。
package hyq.java.sort;
import java.util.Arrays;
public class maopao {
public static void main(String[] args) {
int[] arr={10,23,43,53,64,57,35,25};
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int t=arr[j];
arr[j]=arr[j+1];
arr[j+1]=t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
运行结果：
[10, 23, 25, 35, 43, 53, 57, 64]
Process finished with exit code 0
选择排序
**选择排序：**每次拿一个元素，跟后面剩余的元素，挨个比较，小的往前放，经过一轮比较后，最小的元素就会出现在最前面。
package.java.sort;
import java.util.Arrays;
public class xuanze {
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13,20,30,5,6};
for (int index = 0; index <arr.length-1; index++) {
for (int i = 1 + index; i < arr.length; i++) {
if (arr[index] > arr[i]) {
int t = arr[index];
arr[index] = arr[i];
arr[i] = t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
运行结果：
[5, 6, 13, 20, 24, 30, 57, 69, 80]
Process finished with exit code 0
插入排序
**直接插入排序：**从第二个元素，每次拿一个后面元素插入之前的有序列中，使之仍保持有序。
过程演示：
[4,2,3,5,9,5,6,10,20]
[4]2,3,5,9,5,6,10,20
[2,4] 3, 5, 9, 5, 6, 10, 20
[2,3,4] 5, 9, 5, 6, 10, 20
[2,3,4,5] 9, 5, 6, 10, 20
package.java.sort;
import java.util.Arrays;
public class charu {
public static void main(String[] args) {
int[] arr = {49, 38, 5, 97, 76, 13, 27, 20, 36, 58, 95};
//外层循环定义轮次
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0; j--) {
if (arr[j] < arr[j - 1]) {
int t = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
运行结果：
[5, 13, 20, 27, 36, 38, 49, 58, 76, 95, 97]
Process finished with exit code 0
希尔排序
程序实现
package .java.paixu;
import java.util.Arrays;
public class shellsort {
public static void shellsort(int[ ] arr) {
if(arr==null||arr.length<=1)
return;
int gap=arr.length/2;
while (gap!=0){
for(int i=gap;i<arr.length;i++){
int value=arr[i];
int j=i-gap;
System.out.println("这里是过程1"+ Arrays.toString(arr));
for(;j>=0&&arr[j]>value;j-=gap){
arr[j+gap]=arr[j];
}
arr[j+gap]=value;
}
gap/=2;
System.out.println("这里是过程2"+ Arrays.toString(arr));
}
}
public static void main(String[] args) {
int[] arr={11,10,9,8,7,6,5,4,3,2,1};
shellsort(arr);
System.out.println("这里是结果"+ Arrays.toString(arr));
}
}
结果
这里是过程1[11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
这里是过程1[6, 10, 9, 8, 7, 11, 5, 4, 3, 2, 1]
这里是过程1[6, 5, 9, 8, 7, 11, 10, 4, 3, 2, 1]
这里是过程1[6, 5, 4, 8, 7, 11, 10, 9, 3, 2, 1]
这里是过程1[6, 5, 4, 3, 7, 11, 10, 9, 8, 2, 1]
这里是过程1[6, 5, 4, 3, 2, 11, 10, 9, 8, 7, 1]
这里是过程2[1, 5, 4, 3, 2, 6, 10, 9, 8, 7, 11]//
这里是过程1[1, 5, 4, 3, 2, 6, 10, 9, 8, 7, 11]
这里是过程1[1, 5, 4, 3, 2, 6, 10, 9, 8, 7, 11]
这里是过程1[1, 3, 4, 5, 2, 6, 10, 9, 8, 7, 11]
这里是过程1[1, 3, 2, 5, 4, 6, 10, 9, 8, 7, 11]
这里是过程1[1, 3, 2, 5, 4, 6, 10, 9, 8, 7, 11]
这里是过程1[1, 3, 2, 5, 4, 6, 10, 9, 8, 7, 11]
这里是过程1[1, 3, 2, 5, 4, 6, 10, 9, 8, 7, 11]
这里是过程1[1, 3, 2, 5, 4, 6, 8, 9, 10, 7, 11]
这里是过程1[1, 3, 2, 5, 4, 6, 8, 7, 10, 9, 11]
这里是过程2[1, 3, 2, 5, 4, 6, 8, 7, 10, 9, 11]//
这里是过程1[1, 3, 2, 5, 4, 6, 8, 7, 10, 9, 11]
这里是过程1[1, 3, 2, 5, 4, 6, 8, 7, 10, 9, 11]
这里是过程1[1, 2, 3, 5, 4, 6, 8, 7, 10, 9, 11]
这里是过程1[1, 2, 3, 5, 4, 6, 8, 7, 10, 9, 11]
这里是过程1[1, 2, 3, 4, 5, 6, 8, 7, 10, 9, 11]
这里是过程1[1, 2, 3, 4, 5, 6, 8, 7, 10, 9, 11]
这里是过程1[1, 2, 3, 4, 5, 6, 8, 7, 10, 9, 11]
这里是过程1[1, 2, 3, 4, 5, 6, 7, 8, 10, 9, 11]
这里是过程1[1, 2, 3, 4, 5, 6, 7, 8, 10, 9, 11]
这里是过程1[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
这里是过程2[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]//
这里是结果[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
Process finished with exit code 0
快速排序的方法
快速排序的思想：
分治法：比大小，再分区
1.从数组中取出一个数，作为基准数。
2.分区：将比这个数大或等于的数全放到他的右边，小于他的数全放到他的左边。
3.再对左右区间重复第二步，直到各区间只有一个数。
**实现步骤：**挖坑填数
1.将基准数挖出形成第一个坑。
2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
4.再重复执行2，3两步骤。
package hyq.java.sort;
public class quicksort {
//start 默认是0，end 是数组长度-1
public void quickSort(int[] arr, int start, int end) {
if (start < end) {
int index = getIndex(arr, start, end); //获取分区索引
//对左右两个分区 再进行同样的步骤 ，即是递归调用
quickSort(arr, start, index - 1);//左半部分
quickSort(arr, index + 1, end);//右半部分
}
}
private int getIndex(int[] arr, int start, int end) {
int i = start;
int j = end;
int x = arr[i]; //定义基准数
while (i < j) { //循环
while (i < j && arr[j] >= x) { //从右往左比较
j--;
}
//从右往左找到比基准数小的数了后，填坑
if (i < j) {
//把这个数填到上一个坑位
arr[i] = arr[j];
//让 i++;
i++;
}
//从左往右找
while (i < j && arr[i] < x) {
i++;
}
// 找比基准数大的数，找到后填坑
if (i < j) {
arr[j] = arr[i];
j--;
}
}
//当上面的循环结束后把基准数填到最后一个坑位，也就一基准数为界，分成了左右两部分
arr[i] = x; //把基准数填进去
return i; //返回基准数所在位置的索引
}
}
运行结果：
[5, 13, 20, 27, 36, 38, 49, 58, 76, 95, 97]
Process finished with exit code 0
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
