常见算法
一.选择排序
1选择排序的思想：每轮选择当前位置，开始找出后面的较小值与该位置交换
2选择排序的关键：
（1）确定总共需要选择几轮：数组的长度-1
（2）控制每轮从以前位置为基准，与后面元素选择几次
package com.itheima.d8_sort_binarysearch;
import java.util.Arrays;
/**
* 目标：学会使用选择排序的方法对数组进行排序
*/
public class Test1 {
public static void main(String[] args) {
//1定义数组
int[] arr = {5 , 1 , 3 , 2};
//定义一个循环控制选择几轮：arr.length - 1
for (int i = 0; i < arr.length; i++) {
//i = 0 j = 1 2 3
//i = 1 j = 2 3
//i = 2 j = 3
//3定义内部循环控制选择几次
for (int j = i + 1; j < arr.length; j++) {
//当前位：arr[i]
//如果有比当前位数据更小的，则交换
if (arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
二.二分查找
1二分查找特性
(1)二分查询性能好，二分查找的前提是必须是排好序的数据
(2)二分查找相当于每次去掉一半的查找范围
2二分查找---元素不存在
结论：二分查找正常的检索条件应该是开始位置min <= 结束位置max
3总结：数组的二分查找的实现步骤是什么样的？
（1）定义变量记录左边和右边位置。
（2）使用while循环控制查询（条件是左边位置<=右边位置）
（3）循环内部获取中间元素索引
（4）判断当前要找的元素如果大于中间元素，左边位置=中间索引+1
（5）判断当前要找的元素如果小于中间元素，右边位置=中间索引-1
（6）判断当前要找的元素如果等于中间元素，返回当前中间元素索引
package com.itheima.d8_sort_binarysearch;
/**
* 目标：理解二分搜索的原来并实现
*/
public class Test2 {
public static void main(String[] args) {
//1定义数组
int[] arr = {10, 14, 16, 25, 28, 30, 35, 88, 100};
System.out.println(binarySearch(arr, 35));
}
/**
* 二分查找的实现
* @param arr 排序数组
* @param data 要找的数据
* @return 返回的索引，如果元素不存在，直接返回-1
*/
public static int binarySearch(int[] arr , int data){
//1定义左边位置 右边位置
int left = 0;
int right = arr.length - 1;
//2开始循环，折半查询
while (left <= right) {
//取中间索引
int middleIndex = (left + right) / 2;
//3判断当前中间位置的元素和要找的元素的大小情况
if (data > arr[middleIndex]) {
//往右边找，左边位置更新为 = 中间索引+1
left = middleIndex + 1;
} else if (data < arr[middleIndex]) {
//往左边找，右边位置 = 中间索引-1
right = middleIndex - 1;
} else {
return middleIndex;
}
}
return -1;//查无此元素
}
}
Lambda表达式
一Lambda概述
1Lambda的概述：
（1）Lambda表达式是JDK 8开始后的一种新语法形式
（2）作用：简化匿名内部类的代码写法
2Lambda表达式的简化格式
(匿名内部类被重写方法的形参列表)->{
被重写方法的方法体代码。
}
注：->是语法形式，无实际含义
3注意：Lambda表达式只能简化函数式接口的匿名内部类的写法形式
4什么事函数式接口？
（1）首先必须是接口，其次接口中有且仅有一个抽象方法的形式
（2）通常我们会在接口上加上一个@Functionallnterface注解,标记该接口必须是满足函数式接口
5总结
（1）Lambda表达式的基本作用？
(I)简化函数式接口的匿名内部类的写法
（2）Lambda表达式有什么使用前提？
(I)必须是接口的匿名内部类，接口中只能有一个抽象方法
（3）Lambda的好处？
(I)Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码， 它可以写出更简洁、更灵活的代码，作为一种更紧凑的代码风格，使Java语言表达能力得到 提升。
package com.itheima.d9_lambda;
public class LambdaDemo2 {
public static void main(String[] args) {
//目标：学会使用Lambda的标准格式简化匿名内部类的代码形式
//Lambda只能简化接口中只有一个抽象方法的匿名内部类形式
/*Swimming s1 = new Swimming() {
@Override
public void swim() {
System.out.println("老师游泳贼溜~~~");
}
};
go(s1);*/
Swimming s1 = () ->{
System.out.println("老师游泳贼溜~~~");
};
/*go(s1);
System.out.println("-----------------");
go(new Swimming() {
@Override
public void swim() {
System.out.println("学生游泳很开心~~~");
}
});*/
go(() ->{
System.out.println("学生游泳很开心~~~");
});
}
public static void go(Swimming s){
System.out.println("开始.....");
s.swim();
System.out.println("结束.....");
}
}
@FunctionalInterface //一旦加上这个注解必须是函数式接口，里面只能有一个抽象方法
interface Swimming{
void swim();
}
package com.itheima.d9_lambda;
public class LambdaDemo1 {
public static void main(String[] args) {
//目标：学会使用Lambda的标准格式简化匿名内部类的代码形式
Animal a = new Animal() {
@Override
public void run() {
System.out.println("乌龟跑的很慢！");
}
};
a.run();
}
}
abstract class Animal{
public abstract void run();
}
二.Lambda实战-简化常见函数式接口
package com.itheima.d9_lambda;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Comparator;
public class LambdaDemo3 {
public static void main(String[] args) {
Integer[] ages1 = {34 , 12 , 42 , 23};
/**
* 参数一：被排序的数组必须是引用类型的元素
* 参数而：匿名内部类对象，代表一个比较器对象
*/
/*Arrays.sort(ages1, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;//降序
}
});*/
Arrays.sort(ages1, (Integer o1, Integer o2) -> {
return o1 - o2;//降序
});
System.out.println(Arrays.toString(ages1));
System.out.println("-----------------------");
JFrame win = new JFrame("登录界面");
JButton btn = new JButton("我是一个很大的按钮");
/*btn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("有人点我，点我，点我");
}
});*/
btn.addActionListener((ActionEvent e) -> {
System.out.println("有人点我，点我，点我");
});
win.add(btn);
win.setSize(400 , 300);
win.setVisible(true);
}
}
三.Lambda表达式的省略规则
1Lambda表达式的省略写法（进一步在Lambda表达式的基础上继续简化）
（1）参数类型可以省略不写
（2）如果只有一个参数，参数类型可以省略，同时（）也可以省略
（3）如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写，同时要省略分号！
（4）如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略“；”不写
package com.itheima.d9_lambda;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Comparator;
public class LambdaDemo3 {
public static void main(String[] args) {
Integer[] ages1 = {34 , 12 , 42 , 23};
/**
* 参数一：被排序的数组必须是引用类型的元素
* 参数而：匿名内部类对象，代表一个比较器对象
*/
/*Arrays.sort(ages1, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;//降序
}
});*/
/*Arrays.sort(ages1, (Integer o1, Integer o2) -> {
return o1 - o2;//降序
});*/
Arrays.sort(ages1, ( o1, o2) -> {
return o1 - o2;//降序
});
Arrays.sort(ages1, ( o1, o2) -> o1 - o2);
System.out.println(Arrays.toString(ages1));
System.out.println("-----------------------");
JFrame win = new JFrame("登录界面");
JButton btn = new JButton("我是一个很大的按钮");
/*btn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("有人点我，点我，点我");
}
});*/
btn.addActionListener((ActionEvent e) -> {
System.out.println("有人点我，点我，点我");
});
btn.addActionListener(( e) -> {
System.out.println("有人点我，点我，点我");
});
btn.addActionListener( e -> {
System.out.println("有人点我，点我，点我");
});
btn.addActionListener( e -> System.out.println("有人点我，点我，点我"));
win.add(btn);
win.setSize(400 , 300);
win.setVisible(true);
}
}
教学视频资源来自
Java入门基础视频教程，java零基础自学首选黑马程序员Java入门教程（含Java项目和Java真题）_哔哩哔哩_bilibili
2362
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
