JavaSE进阶:417-431排序算法和String类

最新推荐文章于 2022-09-18 10:58:45 发布

高开低走。

最新推荐文章于 2022-09-18 10:58:45 发布

阅读量185

点赞数

分类专栏：锦到说Java

本文链接：https://blog.csdn.net/qq_43568982/article/details/109540726

版权

锦到说Java 专栏收录该内容

44 篇文章 0 订阅

订阅专栏

开始时间：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]);
        }
    }
}

冒泡排序

给出VBA和C语言的冒泡排序

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

高开低走。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE进阶:417-431排序算法和String类

ArrayTestpackage 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.l
复制链接

扫一扫

专栏目录