P478StringBuliderP480Math类P481Sort方法P483binarySeach 二分查找

本文链接：https://blog.csdn.net/kuimeiyuzu/article/details/122518069

P477测试2

System.out.println("输入名字");
String input= new Scanner(System.in).next();
 System.out.println("输入价格");
 double nums= new Scanner(System.in).nextDouble();
String str1="名字\t\t\t商品价格\n%s\t\t\t%s";
String s=nums+"";
StringBuffer s1=new StringBuffer(s);
//找到小数点的索引，超前插入
 for (int i = s1.lastIndexOf(".")-3; i >0 ; i-=3) {
     s1.insert(i,".");
 }
 System.out.println(String.format(str1,input ,s1));

P478StringBulider

//1. StringBuilder 继承 AbstractStringBuilder 类
// 2. 实现了 Serializable ,说明 StringBuilder 对象是可以串行化(对象可以网络传输,可以保存到文件)
// 3. StringBuilder 是 final 类, 不能被继承
// 4. StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder 的 char[] value;
// 因此，字符序列是堆中
// 5. StringBuilder 的方法，没有做互斥的处理,即没有 synchronized 关键字,
// 因此在单线程的情况下使用
StringBuilder stringBuilder = new StringBuilder();

StringBuilder stringBuilder = new StringBuilder();
long startTime = 0L;
long endTime = 0L;
StringBuffer buffer = new StringBuffer("");
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {
    buffer.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer 的执行时间：" + (endTime - startTime));
//同理buffer
String text = "";
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {
    text = text + i;
}
endTime = System.currentTimeMillis();
System.out.println("String 的执行时间：" + (endTime - startTime));

P480Math类

int abs = Math.abs(-9);//1.绝对值
System.out.println(abs);//9
//2.pow 求幂
double pow = Math.pow(2, 4);//2 的4 次方
System.out.println(pow);//16
// 3.ceil 向上取整,返回>=该参数的最小整数(转成double);天花板
double ceil = Math.ceil(3.9);
System.out.println(ceil);//4.0
// 4.floor 向下取整，返回<=该参数的最大整数(转成double)
double floor = Math.floor(4.01);
System.out.println(floor);//4.0
// 5.round 四舍五入Math.floor(该参数+0.5)
long round = Math.round(5.51);
System.out.println(round);//6
// 6.sqrt 求开方
double sqrt = Math.sqrt(9.0);
System.out.println(sqrt);//3.0
// 7.random 求随机数
// random 返回的是0 <= x < 1 之间的一个随机小数
// 思考：请写出获取a-b 之间的一个随机整数,a,b 均为整数，比如a = 2, b=7
// 即返回一个数x 2 <= x <= 7
// 老韩解读Math.random() * (b-a) 返回的就是0 <= 数<= b-a
// (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
//因为是前闭后开Math.random() * (b-a )范围0<=x<5，所以还需要加1
// (2) 使用具体的数给小伙伴介绍a = 2 b = 7
// (int)(a + Math.random() * (b-a +1) ) = (int)( 2 + Math.random()*6)
// Math.random()*6 返回的是0 <= x < 6 小数
// 2 + Math.random()*6 返回的就是2<= x < 8 小数,最后强转成整数为0-7
//总结就是(int) (a+Math.random()*(b-a+1)),范围是0-7的整数
//(3) 公式就是(int)(a + Math.random() * (b-a +1) )
// max , min 返回最大值和最小值
int min = Math.min(1, 9);
int max = Math.max(45, 90);
System.out.println("min=" + min);//1
System.out.println("max=" + max);//90

P481java-Array

ToString方法的源码，非常的清晰明了

P481Sort方法与Sort方法

Integer []integers={-7,-20,9,24,1,20,90};
Arrays.sort(integers);
System.out.println(Arrays.toString(integers));//输出正序
//1. 可以直接使用冒泡排序, 也可以直接使用Arrays 提供的sort 方法排序
// 2. 因为数组是引用类型，所以通过sort 排序后，会直接影响到实参arr

// 3. sort 重载的，也可以通过传入一个接口Comparator 实现定制排序
//4. 调用定制排序时，传入两个参数(1) 排序的数组arr
//第一个参数传入数组，第二个传入new Comparator<Integer>()
//(2) 实现了Comparator 接口的匿名内部类, 要求实现compare 方法
Arrays.sort(integers, new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        Integer i1=(Integer) o1;
        Integer i2=(Integer) o2;
        return i2-i1;
    }
});
System.out.println(Arrays.toString(integers));
//输出[90, 24, 20, 9, 1, -7, -20]
// 6. 这里体现了接口编程的方式, 看看源码，就明白(这个源码太复杂了，目前的我还不行)
//源码分析
//(1) Arrays.sort(arr, new Comparator()
// (2) 最终到TimSort 类的private static <T> void binarySort(T[] a, int lo, int hi, int start,
// Comparator<? super T> c)()
// (3) 执行到binarySort 方法的代码, 会根据动态绑定机制c.compare()执行我们传入的
// 匿名内部类的compare ()
// while (left < right) {
// int mid = (left + right) >>> 1;
// if (c.compare(pivot, a[mid]) < 0)
// right = mid;
// else
// left = mid + 1;}//个人觉得类似于二分排序，类似于leetcode的找两数之和的答案

P482自己写一段冒泡排序

public class Hello {
    public static void main(String[] args) {
        int []arr={1,7,-1,3,6,10,9};
       // bubble01(arr);
        bub2(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
               int i1=(Integer) o1;
               int i2=(Integer) o2;
               return i2-i1;
               //看源码，其实是在内部进行比较
            }
        });
        System.out.println(Arrays.toString(arr));
    }
    public static void bubble01(int[] arr){
        int temp=0;
        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]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
    //结合冒泡加排序
    public static void bub2(int []arr,Comparator c){
        int temp=0;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                //数组由于下面的c.compare的值返回的结果
                if(c.compare(arr[j],arr[j+1])>0){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
}

P483java-Arrays binarySeach 二分查找

Integer []arr={1,2,44,55,99,122};
// binarySearch 通过二分搜索法进行查找，要求必须排好序（已经）
// 老韩解读
// 1. 使用binarySearch 二叉查找
// 2. 要求该数组是有序的. 如果该数组是无序的，不能使用binarySearch
// 3. 如果数组中不存在该元素，就返回return -(low + 1); // key not found.
//而在返回的low意思是本来该在位置
//源码：先找low=0,higth=arr.length-1,先找中间的mid=low+higth，然后继续左右两边依次比较...
int index=Arrays.binarySearch(arr,123);//输出-7，low=6
System.out.println(index);
//数组元素的拷贝,从arr数组中，拷贝arr.length元素到newArr数组中
//2. 如果拷贝的长度> arr.length 就在新数组的后面增加null
// 3. 如果拷贝长度< 0 就抛出异常NegativeArraySizeException
// 4. 该方法的底层使用的是System.arraycopy()
Integer[] newArr=Arrays.copyOf(arr,arr.length);
System.out.println(Arrays.toString(newArr));
/*
Integer[] newArr1=Arrays.copyOf(arr,arr.length-1);
System.out.println(Arrays.toString(newArr1));//输出[1, 2, 44, 55, 99]
Integer[] newArr2=Arrays.copyOf(arr,arr.length+1);
System.out.println(Arrays.toString(newArr2));//输出[1, 2, 44, 55, 99，122，null]
-1返回negative异常,0返回[]

 */
//ill 数组元素的填充
Integer[] num = new Integer[]{9,3,2};
//老韩解读
// 1. 使用99 去填充num 数组，可以理解成是替换原理的元素
Arrays.fill(num, 99);
System.out.println("==num 数组填充后==");
System.out.println(Arrays.toString(num));//输出[99, 99, 99]
//equals 比较两个数组元素内容是否完全一致
Integer[] arr2 = {1, 2, 90, 123};
//老韩解读
// 1. 如果arr 和arr2 数组的元素一样，则方法true;
// 2. 如果不是完全一样，就返回false
boolean equals = Arrays.equals(arr, arr2);
System.out.println("equals=" + equals);
//asList 将一组值，转换成list
// 老韩解读
// 1. asList 方法，会将(2,3,4,5,6,1)数据转成一个List 集合
// 2. 返回的asList 编译类型List(接口)
// 3. asList 运行类型java.util.Arrays#ArrayList, 是Arrays
// 类的,静态内部类private static class ArrayList<E> extends AbstractList<E>
// implements RandomAccess, java.io.Serializable
List asList = Arrays.asList(2,3,4,5,6,1);//list是一个接口
System.out.println("alist="+asList);//输出alist=[2, 3, 4, 5, 6, 1]
System.out.println("asList 的运行类型" + asList.getClass());//
//输出sList 的运行类型class java.util.Arrays$ArrayList

P484Arrays类的练习

public class Hello {
    public static void main(String[] args) {
        Book[]books= new Book[4];
        books[0]=new Book("red",100);
        books[1]=new Book("red1",99);
        books[2]=new Book("red22",5);
        books[3]=new Book("red333",300);//如果发现不一样，可以灵活修改1和-1的值
        Arrays.sort(books, new Comparator() {
            @Override
            public int compare(Object o1,Object o2) {
                Book book1=(Book) o1;
                Book book2=(Book) o2;
                int Pr= book2.getPrice()-book1.getPrice();
                //若是改为书名长度，上句修改为 
                //int Pr= book2.getName().length()-book1.getName().length();
                
                if( Pr>0){
                    return -1;
                }else if(Pr<0){
                    return 1;
                }else{
                    return 0;
                }
            }
        });
        System.out.println(Arrays.toString(books));//输出
        //[Book{name='red22', price=5}, Book{name='red1', price=99}, 
        // Book{name='red', price=100}, Book{name='red333', price=300}]
    }
}


class Book{
    private String name;
    private int price;

    public Book(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}