Java常见算法和lambda

查找算法

public class day11 {
    public static void main(String[] args)  {
        //基本查找 / 顺序差宅
        //核心:
        //从0索引开始挨个往后查找

        //需求:定义一个方法利用基本查找 查询某个元素是否存在
        //数据如下:{131,127,147,81,103,23,7,79}
        int[] arr={131,127,147,81,103,23,7,79};
        int number=81;
        System.out.println(basicSearch(arr, number));
    }
    public static boolean basicSearch(int[] arr,int number){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==number){
                return true;
            }
        }
        return false;
    }
}

import java.util.ArrayList;

public class day11 {
    public static void main(String[] args)  {

        //需求:定义一个方法利用基本查找 查询某个元素在数组中的索引
        //要求:需要考虑数组中元素有重复的可能性

        int[] arr={131,127,147,81,103,23,7,79,81};
        //要返回3 8
        int number=81;
        System.out.println(basicSearch(arr, number));//[3, 8]
    }
    //心得:如果我们要返回多个数据的话 可以把这些数据放到数组或者集合中.
    public static ArrayList basicSearch(int[] arr,int number){
        ArrayList<Integer>list = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==number){
                list.add(i);
            }
        }
        return list;
    }
}

public class day11 {
    public static void main(String[] args)  {
        int[] arr={7,23,79,81,103,127,131,147};
        System.out.println(binaryResearch(arr,147));
    }
    public static int binaryResearch(int[] arr,int k){

        int max =arr.length-1;
        int min =0;
        while(true){
            if(min>max){
                return -1;
            }
            int mid =(min+max)/2;
            if(arr[mid]>k){
                max=mid-1;
            }else if(arr[mid]<k){
                min=mid+1;
            }else{
                return mid;
            }
        }


    }


}

现实生活中不可能都这样大部分都是一些有顺序一些无顺序

public class day11 {
    public static void main(String[] args) {
        int[] arr = {16, 5, 9, 12, 21, 18,
                32, 23, 37, 26, 45, 34,
                50, 48, 61, 52, 73, 66};
        //1.要把数据进行分块
        //要分几块 18开根号 4.24块
        //18/4=4.5

        //创建三个块的对象
        Block b1 =new Block(21,0,5);
        Block b2 =new Block(45,6,11);
        Block b3 =new Block(73,12,17);

        //定义数组来管理三个块的对象(索引表)
        Block[] blockArr={b1,b2,b3};
        //定义一个变量用来记录要查找的元素
        int number=37;
        //调用方法:传递索引表,数组,要查找的元素
        int index =getIndex(blockArr,arr,number);
        //打印一下
        System.out.println(index);
    }
    //利用分块查找的原理 查询number的索引
    //1.确定number在索引标的位置
    private static int getIndex(Block[] blockArr,int[] arr,int number){
        int indexBlock = findIndexBlock(blockArr,number);
        if(indexBlock==-1){
            //表示number不在数组当中的
            return -1;
        }

        //获取这一块的起始索引和结束索引
        int startIndex =blockArr[indexBlock].getStartIndex();
        int endIndex =blockArr[indexBlock].getEndIndex();
        //遍历
        for(int i=startIndex;i<=endIndex;i++){
            if(arr[i]==number){
                return i;
            }
        }
        return -1;
    }
    //定义一个方法 用来确定number在那一块中
    public static int findIndexBlock(Block[] blockArr,int number){
//        Block b1 =new Block(21,0,5);-----0
//        Block b2 =new Block(45,6,11);----1
//        Block b3 =new Block(73,12,17);---2

        //从0索引开始遍历blockArr,如果number小于max,那么就表示number就是在这一块当中的
        for (int i = 0; i < blockArr.length; i++) {
            if(number<=blockArr[i].getMax()){
                return i;
            }
        }
        return -1;


    }
}
class Block {
    private int max;//最大值
    private int startIndex;//起始索引
    private int endIndex;//结束索引

    public Block() {
    }

    public Block(int max, int startIndex, int endIndex) {
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    /**
     * 获取
     * @return max
     */
    public int getMax() {
        return max;
    }

    /**
     * 设置
     * @param max
     */
    public void setMax(int max) {
        this.max = max;
    }

    /**
     * 获取
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }

    /**
     * 设置
     * @param startIndex
     */
    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }

    /**
     * 获取
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }

    /**
     * 设置
     * @param endIndex
     */
    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }

    public String toString() {
        return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

排序算法

public class day11 {
    public static void main(String[] args) {
       //冒泡排序
        //核心思想:
        //相邻的两个元素两两比较 大的放右边,小的放左边
        //第一轮比较完毕之后,最大值就已经确定了,第二轮可以减少循环一次 后面一次类推
        //如果数组中有n个数,总共只需要执行n-1次循环就可以了
        //1.定义数组
        //2.利用冒泡排序将数组中的数据变成12345
        //第一轮:
        //结束之后,最大值在数组的最右边 ....5
        int[] arr={2,4,5,3,1};
        //i表示数组中每个元素的索引 0 1 2 3 4
        for(int i=0;i<arr.length-1;i++){//0 1 2 3
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }//-1:为了防止索引越界
                //-i:提升效率 每一轮执行的次数应该比上一轮少一次
            }
        }
        printArr(arr);


    }
    public static void printArr(int[] arr){
        for(int k=0;k<arr.length;k++){
            System.out.print(arr[k]+" ");
        }
        System.out.println();
    }


}

public class day11 {
    public static void main(String[] args) {
       //选择排序
//        int[] arr={2,4,5,3,1};
//        for (int i = 0+1; i < arr.length; i++) {
//            if(arr[0]>arr[i]){
//                int temp=arr[0];
//                arr[0]=arr[i];
//                arr[i]=temp;
//            }
//        }

        //最终代码
        int[] arr={2,4,5,3,1};
        //外循环:几轮
        //i:表示这一轮中 我拿着那个索引上的数据跟后面的数据进行比较并交换
        for (int i = 0; i < arr.length-1; i++) {
            //内循环:每一轮干什么事情
            //拿着i跟i后面的数据进行交换
            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;
                }
            }
        }
        printArr(arr);


    }
    public static void printArr(int[] arr){
        for(int k=0;k<arr.length;k++){
            System.out.print(arr[k]+" ");
        }
        System.out.println();
    }


}

将无序插入有序

public class day11 {
    public static void main(String[] args) {
      //插入排序
        int[] arr={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};

        //1.找到无序的那组数据
        int startIndex=-1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>arr[i+1]){
                //System.out.println(i+1);
                startIndex=i+1;
                break;
            }
        }
        //2.遍历从startIndex开始到最后一个元素,依次得到无序的那一组数据中的每一个元素
        for (int i = startIndex; i < arr.length; i++) {
            //System.out.println(arr[i]);
            //问题:如何把遍历到的数据,插入到前面有序的这一组当中

            //记录当前要插入数据的索引
            int j=i;
            while(j>0&&arr[j]<arr[j-1]){
                int temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
                j--;
            }

            //修改这个索引
        }
        printArr(arr);


    }
    public static void printArr(int[] arr){
        for(int k=0;k<arr.length;k++){
            System.out.print(arr[k]+" ");
        }
        System.out.println();
    }


}

public class day11 {
    public static void main(String[] args) {
        //递归求和
        //大问题->小问题
        //1~100=100+1~99
        System.out.println(getSum(100));//5050
    }
    public static int getSum(int number){
        if(number==1){
            return 1;
        }
        return number+getSum(number-1);
    }
}

public class day11 {
    public static void main(String[] args) {
        System.out.println(FactorialRecursion(5));
    }
    public static int FactorialRecursion(int number){
        if(number==1){
            return 1;
        }
        //方法再调用时 参数必须更靠近出口
        return number*FactorialRecursion(number-1);
    }
}

public class test {
    public static void main(String[] args) {
        int[] arr={6,1,2,7,9,3,4,5,10,8};
        quickSort(arr,0,arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
    public static void quickSort(int[] arr,int i,int j){
        //记录两个变量记录查找的范围
        int start=i;
        int end=j;

        if(start>end){
            return;//递归的出口
        }
        //记录基准数
        int baseNumber=arr[i];

        //利用循环找到要交换的数字
        while(start!=end){
            //利用end，从后往前开始找，找比基准数小的数字
            while(true){
                if(end<=start||arr[end]<baseNumber){
                    break;
                }
                end--;
            }
            //利用start，从前往后找 ，找比基准数打的数字
            while(true){
                if(end<=start||arr[start]>baseNumber){
                    break;
                }
                start++;
            }
            //把end和start指向的元素进行交换
            int temp=arr[start];
            arr[start]=arr[end];
            arr[end]=temp;

        }
        /*
         * 参数一：要排序的数组
         * 参数二：要排序数组的起始索引
         * 参数三：要排序数组的结束索引
         * */

        //当start和end指向了同一个元素 那么上面的循环就会结束
        //表示以及找到了基准数在数组中应存入的位置
        //基准数归位
        //就算拿着这个范围中的第一个元素 根start指向的元素进行交换
        int temp=arr[i];
        arr[i]=arr[start];
        arr[start]=temp;

        //确定6左边的范围,重复刚刚的事情
        quickSort(arr,i,start-1);
        //右边
        quickSort(arr,start+1,j);

    }


}

不能先移动start 不然会造成下面的结果

Arrays

数组的工具类

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        //toString:将数组变成字符串
        System.out.println("----------toString-----------");
        int[] arr={1,2,3,4,5,6,7,8,9,10};
        System.out.println(Arrays.toString(arr));
        
        //binarySearch:二分查找查找元素
        //细节1:二分查找的前提 数组中的元素必须是有序的 数组中的元素必须是升序的
        //细节2:如果要查找的元素是存在的 那么返回真实的索引
        //但是,如果要查找的元素是不存在的,返回的是-插入点-1
        //为什么-1?
        //解释:如果此时要查找的数字是0 如果返回-插入点,就会出现问题 因为按照上面的规则返回值是-插入点 也就是-0 -0也是0
        //为了避免这样的情况 Java就减一
        System.out.println("----------binarySearch--------");
        System.out.println(Arrays.binarySearch(arr, 10));
        System.out.println(Arrays.binarySearch(arr, 2));
        System.out.println(Arrays.binarySearch(arr, 20));//-11
        
        //copyOf:拷贝数组
        //参数一:老数组
        //参数二:新数组的长度
        //方法的底层会根据第二个参数来创建新的数组
        //新数组小于 部分拷贝
        //新数组 大于 补上默认初始化值0
        System.out.println("---------copyOf-------------");
        int[] newArr1 =Arrays.copyOf(arr,20);
        System.out.println(Arrays.toString(newArr1));
        
        //copyOfRange:拷贝数组(指定范围)
        //细节:包头不包尾
        System.out.println("----------copyOfRange---------");
        int[] newArr2=Arrays.copyOfRange(arr,0,9);
        System.out.println(Arrays.toString(newArr2));
        
        //fill:填充数组
        System.out.println("------------fill---------------");
        Arrays.fill(arr,100);
        System.out.println(Arrays.toString(arr));
        
        //sort:排序 默认情况下,给基本数据类型进行升序排序
        //底层使用的是快速排序.
        System.out.println("----------sort------------");
        int[] arr2={10,2,3,5,6,1,7,8,4,9};
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));


    }
}

import java.util.Arrays;
import java.util.Comparator;

public class test {
    public static void main(String[] args) {
        /*public static void sort(数组,排列规则) 按照指定的规则排序
        *
        * 参数一:要排序的数组
        * 参数二:排序的规则
        * 细节:
        * 只能给引用数据类型的数组进行排序
        * 如果数组是基本数据类型的 ,需要变成其对于的包装类
        * */
        Integer[] arr={2,3,1,5,6,7,8,4,9};
        //第二个参数是一个接口 所以我们在调用方法的时候 需要传递这个接口的实现类对象 作为排序的规则
        //但是这个实现类 只要使用一次 所以就没有必要单独去写一个类 直接才去匿名内部类的方式就可以了

        //底层原理:
        //利用插入排序+二分查找到方式进行排序的
        //默认把0索引的数据当做是有序的序列,1索引到最后当做无序序列
        //遍历无序的序列得到里面的每一个元素 假设当前遍历得到的元素是A元素
        //把A往有序序列中进行插入,在插入的时候,是利用二分查找确定A元素的插入点
        //拿着A元素 跟插入点的元素进行比较 比较的规则就是compare的方法的方法体
        //如果方法的返回值是负数,拿着A继续跟前面的数据进行比较
        //如果方法的返回值是正数,拿着A继续跟后面的数据进行比较
        //如果方法的返回值是0,也拿着A跟后面的数据进行比较
        //直到能够确定A的最终位置为止

        //compare方法的心事参数:
        //参数1 o1: 表示在无序序列中 遍历得到的每一个元素
        //参数2 o2: 有序序列中的元素

        //返回值:
        //负数:表示当前要插入的元素是小的 放在前面
        //正数:表示当前要插入的元素是大的 放在后面
        //0:表示当前要插入的元素跟现在的元素比是一样的 也会放在后面
        
        //简单理解:
        //o1-o2:升序排列
        //o2-o1:降序排列
        
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("--------------");
                System.out.println("o1:"+o1);
                System.out.println("o2:"+o2);
                return o1-o2;
            }
        });
        System.out.println(Arrays.toString(arr));
        


    }
}

Lambda表达式

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        //初始Lambda表达式 - 简化匿名内部类的书写
        Integer[] arr={2,3,1,5,6,7,8,4,9};

//        Arrays.sort(arr, new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o1-o2;
//            }
//        });


        Arrays.sort(arr, (Integer o1, Integer o2)-> {
                return o1-o2;
            }
        );
        System.out.println(Arrays.toString(arr));



    }
}

public class test {
    public static void main(String[] args) {
    //1.利用匿名内部类的形式去调用下面的的方法
        //调用一个方法的时候,如果方法的形参是一个接口,那么我们要传递这个接口的实现类对象
        //如果实现类对象只要用到一次,就可以用匿名内部类的形式进行书写

//        method(new Swim() {
//            @Override
//            public void swimming() {
//                System.out.println("正在游泳");
//            }
//        });

        //2.利用lambda表达式进行改写
        method(
                ()->{
                    System.out.println("正在游泳");
                }
        );


    }
    public static void method(Swim s){
        s.swimming();
    }
}
@FunctionalInterface
interface Swim{
    public abstract void swimming();
}

import java.util.Arrays;
import java.util.Comparator;

public class test {
    public static void main(String[] args) {
        Integer[] arr={2,3,1,5,6,7,8,4,9};

        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });

        //Lambda完整格式
        Arrays.sort(arr,(Integer o1, Integer o2)-> {
                return o1-o2;
            }
        );

        //Lambda省略写法
        Arrays.sort(arr,( o1, o2)-> o1-o2);



        System.out.println(Arrays.toString(arr));
    }
}

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        String[] arr={"a","aaaa","aaa","aa"};

        //如果以后我们要把数组中的数据按照指定的方式进行排列 就需要用到sort方法,而且要制定排序的规则
//        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照字符串长度进行排序

                return o1.length()-o2.length();
            }
        });


//        Arrays.sort(arr,(String o1, String o2)-> {
//                //按照字符串长度进行排序
//
//                return o1.length()-o2.length();
//            }
//        );

        Arrays.sort(arr,( o1, o2)->o1.length()-o2.length());


        //打印数组
        System.out.println(Arrays.toString(arr));
    }
}

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        //前置知识 用compareTo来比较两个字符串
//        String s1="a";//97
//        String s2="b";//98
//        int i=s1.compareTo(s2);
//        System.out.println(i);//-1 s1<s2

        //1.创建三个女朋友的对象
        GirlFriend gf1 =new GirlFriend("xiaoshishi",18,1.67);
        GirlFriend gf2 =new GirlFriend("xiaodandan",19,1.72);
        GirlFriend gf3 =new GirlFriend("xiaohuihui",19,1.78);

        //2.定义数组存储女朋友信息
        GirlFriend[] arr={gf1,gf2,gf3};

        //3.利用Arrays中的sort方法进行排序
        //匿名内部类 Lambda
//        Arrays.sort(arr, new Comparator<GirlFriend>() {
//            @Override
//            public int compare(GirlFriend o1, GirlFriend o2) {
//                double temp = o1.getAge() - o2.getAge();
//                temp = temp==0?o1.getHeight()-o2.getHeight():temp;
//                temp = temp==0?o1.getName().compareTo(o2.getName()):temp;
//                if(temp>0){
//                    return 1;
//                }else if(temp<0){
//                    return -1;
//                }else{
//                    return 0;
//                }
//
//            }
//        });


        Arrays.sort(arr, (o1,o2)-> {
                double temp = o1.getAge() - o2.getAge();
                temp = temp==0?o1.getHeight()-o2.getHeight():temp;
                temp = temp==0?o1.getName().compareTo(o2.getName()):temp;
                if(temp>0){
                    return 1;
                }else if(temp<0){
                    return -1;
                }else{
                    return 0;
                }

            }
        );
        //展示一下数组中的内容
        System.out.println(Arrays.toString(arr));


    }
}

public class GirlFriend {
    private String name;
    private int age;
    private double height;

    public GirlFriend() {
    }

    public GirlFriend(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return height
     */
    public double getHeight() {
        return height;
    }

    /**
     * 设置
     * @param height
     */
    public void setHeight(double height) {
        this.height = height;
    }

    public String toString() {
        return "GirlFriend{name = " + name + ", age = " + age + ", height = " + height + "}";
    }
}

public class test {
    public static void main(String[] args) {
//        //方法一:
//        //1.创建一个长度为12的数组
//        int[] arr=new int[12];
//        //2.手动给0索引和1索引的数据进行赋值
//        arr[0]=1;
//        arr[1]=1;
//        
//        //3.利用循环给剩余的数据进行赋值
//        for(int i=2;i<arr.length;i++){
//            arr[i]=arr[i-1]+arr[i-2];
//        }
//        //1 1 2 3 5 8 13...
//        
//        //获取最大索引上的数据即可
//        System.out.println(arr[11]);
        
        //方法二:
        //1.递归出口
        //2.递归规律
        System.out.println(getSum(12));

    }
    public static int getSum(int month){
        if(month==1||month==2){
            return 1;
        }
        return getSum(month-1)+getSum(month-2);
    }
}

public class test {
    public static void main(String[] args) {
        /*day10:1
        day9:(day10+1)*2 =4
        day8:(day9+1)*2 =10
        * */
        System.out.println(getCount(1));

    }
    public static int getCount(int day){
        if(day<=0||day>=11){
            System.out.println("当前时间错误");
            return -1;
        }
        if(day==10){
            return 1;
        }
        return (getCount(day+1)+1)*2;
    }
}