开始时间:2020-11-07
ArrayTest
package BUPT;
import java.util.Arrays;
public class ArraysTest {
public static void main(String[] args) {
int[] arr = {2, 3, 32, 4, 5, 322};
Arrays.sort(arr);
//封装好的排序方法,和Python类似
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
冒泡排序
package BUPT;
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {152, 28, 333, 27, 22, 111};
myprint(arr);
int temp;
for (int j = 0; j < arr.length; j++) {
for (int i = 0; i < arr.length - j - 1; i++) {
if (arr[i] > arr[i + 1]) {
temp = arr[i + 1];
arr[i + 1] = arr[i];
arr[i] = temp;
}
}
}
myprint(arr);
}
public static void myprint(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
冒泡每次冒都要交换位置
选择排序
package BUPT;
import static BUPT.BubbleSort.myprint;
/*
每次从这堆参与比较的数据中
选择最小的和最前面的交换位置
每次交换一定是有意义的
*/
public class SelectSort {
public static void main(String[] args) {
int[] arr = {35, 2, 311, 220, 32};
myprint(arr);
int temp;
for (int i = 0; i < arr.length; i++) {
//内层循环从i+1开始,因为i能够确定是最小了
int min = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
if (min != i) {
temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
myprint(arr);
}
myprint(arr);
}
}
输出结果为
35 2 311 220 32 //初始状态
2 35 311 220 32 //先认为35最小,比较出来结果是2最小,所以2和35交换
2 32 311 220 35 //此时35在arr[1]的位置,认为arr[1]位置最小,然后32比35小,交换32和35的位置
2 32 35 220 311 //此时认为311所在的arr[2]最小,实际上35是最小的,交换311和35的位置
2 32 35 220 311 //此时认为35所在的arr[3]最小,此时就是他最小,不交换
2 32 35 220 311 //此时认为220所在的arr[4]最小,此时就是他最小,不交换
2 32 35 220 311 //结束状态的数组
一共参与的是arr.length-1次
查找
比较笨的查找
package BUPT20201107;
import java.util.Scanner;
public class ArraySearch {
public static void main(String[] args) {
int[] arr = {4, 5, 3, 222, 3};
Scanner s = new Scanner(System.in);
System.out.println("请输入要查找的数字:");
int k = s.nextInt();
MySearch(arr, k);
}
public static void MySearch(int[] array, int k) {
for (int i = 0; i < array.length; i++) {
if (array[i] == k) {
System.out.println("222元素的下标为" + i);
return;
}
}
System.out.println("该元素不存在!");
}
}
二分法查找
用二分法的前提是数组连续且有序
建立在排序的基础之上
没建立的方法,用alt+enter即可实现方法创建
package BUPT20201107;
public class BiSearch {
public static void main(String[] args) {
int[] arr = {10, 33, 222, 333, 445};
int index = BinarySearch(arr, 333);
System.out.println(index == -1 ? "该元素不存在" : "该元素下标为" + index);
}
private static int BinarySearch(int[] arr, int k) {
int begin = 0;
int end = arr.length - 1;
while (begin < end) {
//mid取中间,注意别放出循环外
int mid = (begin + end) / 2;
if (arr[mid] == k) {
return mid;
} else if (arr[mid] < k) {
begin = mid + 1;
} else {
end = mid - 1;
}
}
//该元素不存在
return -1;
}
}
Arrays工具类
这个操作有点像Python,参考
https://blog.csdn.net/qq_43568982/article/details/104605118
package BUPT20201107;
import java.util.Arrays;
public class ArraysTest {
public static void main(String[] args) {
//java.util.Arrays工具类
//所有方法都是静态的,直接用类名调用
//主要用二分法查找和排序
int[] arr = {41, 32, 53, 74, 52, 3333, 222, 0};
Arrays.sort(arr);
myprint(arr);
int index = Arrays.binarySearch(arr, 74);
System.out.println(index == -1 ? "该元素不存在" : "该元素的下标是" + index);
}
public static void myprint(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
String字符串
String字符串的存储原理
package BUPT20201107;
//String放在“字符串常量池”里面
public class StringTest {
public static void main(String[] args) {
String s1="abc";
String s2="abc"+"de";
String s3=new String("xy");
//凡是双引号括起来的,都在字符串常量池中有一份
//new对象,一定在堆内存当中开辟空间,s3和s1的方式是不一样的
}
}
当s1和s2中字符串相同时,指向的也是同一个字符串常量池,所以s1==s2
package BUPT20201107;
//String放在“字符串常量池”里面
public class StringTest {
public static void main(String[] args) {
String s2 = "xyz";
String s3 = new String("xyz");
String s4 = new String("xyz");
//s2直接指向字符串常量池,s3先指向堆内存的String对象地址,再指向字符串常量池
//这里的equals方法是重写过的,直接比较两个常量是否相等,返回true
System.out.println(s2.equals(s3));
//但是直接写等号,比较的是s2和s3存的地址,s3存的是对象地址,所以两者不等,false
System.out.println(s2 == s3);
//用equals比较比较常量,返回true
System.out.println(s3.equals(s4));
//用等号比较的是对象地址,返回false
System.out.println(s3 == s4);
}
}
分析一共有几个对象
package BUPT20201108;
//分析一共有几个对象
public class StringTest {
public static void main(String[] args) {
//一共是三个对象, "abc" 和 堆内存new的两个对象
//s1和s2不算里面
String s1=new String("abc");
String s2=new String("abc");
}
}
String常用的构造方法
package BUPT20201108;
public class StringTest02 {
public static void main(String[] args) {
byte[] bytes={97,98,99};
String s1=new String(bytes);
System.out.println(s1);
}
}
输出为abc
读取byte数组时自动把数字转为了asc码
也可以写成这个样子
String s2 = new String(bytes, 1, 2);
System.out.println(s2);
其中1是偏移量,2是输出长度
因此sout之后得到的是bc
package BUPT20201108;
public class StringTest02 {
public static void main(String[] args) {
char[] chars = {'你', '好', '程', '序', '员'};
String s3 = new String(chars);
//输出为你好程序员
System.out.println(s3);
//两个偏移量,长度为三,输出为程序员
String s4 = new String(chars, 2, 3);
System.out.println(s4);
}
}
结束时间:2020-11-08