java-api+匿名内部类+lambda
BigInteger
package APIlearn;
import java.math.BigDecimal;
import java.math.BigInteger;
public class Intergertest {
public static void main(String[] args) {
//Integer-learning
Integer i = Integer.valueOf("200");
System.out.println(i);
int num = i.intValue();
System.out.println(num);
//字符串转化为整数，不能有字母
int num2 = Integer.parseInt("123");
System.out.println(num2);
//十转二
String Str1 = Integer.toBinaryString(18);
System.out.println(Str1);
//十转八
String Str3 = Integer.toOctalString(26);
System.out.println(Str3);
//bigInteger-learning
//创建对象,构造，无限长
BigInteger b1 = new BigInteger("134");
System.out.println(b1);
//静态方法获取对象，有限长度long
BigInteger b2 = BigInteger.valueOf(134);
System.out.println(b1 == b2);//false
//成员方法，知道即可
//BigDecimal
char[] c1 = {'1', '2', '3'};
BigDecimal bd1 = new BigDecimal(c1);
System.out.println(bd1);
BigDecimal bd2 = new BigDecimal("1.3");
System.out.println(bd2);
//静态方法
BigDecimal bd3 = BigDecimal.valueOf(134.78);
}
}
匿名内部类
package APIlearn;
public class innertest {
public static void main(String[] args) {
//匿名内部类
new Swim(){
@Override
public void swim() {
System.out.println("重写了游泳的方法");
}
};
//继承关系
new Animal(){
@Override
//方法的重写
public void eat() {
//super.eat();
System.out.println("重写了eat方法");
}
};
// Dog d=new Dog();
// method(d);
//dog类我只要用一次，那么还需要单独定义一个类太麻烦
method(
new Animal() {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
);
}
//要自己写一个子类
public static void method(Animal a){
a.eat();
}
}
package APIlearn;
public abstract class Animal {
public void eat(){}
}
package APIlearn;
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
package APIlearn;
public interface Swim {
public abstract void swim();
}
package APIlearn;
public class Person implements Swim{
@Override
public void swim() {
System.out.println("重写游泳的方法");
}
}
lambda表达式：
前置知识：
Java集合框架方法体系详解
完全可以，这些方法不是凭空冒出来的，它们都属于 Java 集合框架（Java Collections Framework, JCF）这套完整的体系里。我从「顶层设计 → 分层职责 → 具体方法来源」给你串一遍，你就能清楚它们从哪来、为什么存在、各自属于哪一层。
一、先搭整体框架：集合相关的东西分两大类
你接触到的所有集合相关代码，本质就两类，先把这个边界分清：
|
类别 |
作用 |
代表例子 |
调用方式 |
|
集合本身（容器） |
存数据、管理数据 |
List、ArrayList、Set、HashMap |
|
|
集合工具 / 扩展能力 |
对容器做通用操作 |
Collections 工具类、接口默认方法 |
工具类： |
你困惑的两个方法刚好分属两类：
-
fruits.forEach()→ 属于集合自身继承来的默认方法 -
Collections.sort()→ 属于外部工具类提供的静态方法
下面我们从上到下捋清楚每一层的职责，你就知道它们为什么会出现。
二、第一大类：集合自身的方法体系（层层继承而来）
Java 的集合是严格的接口继承体系，方法是从上往下一层层继承下来的，不是每个类自己随便加的。核心继承链：
Iterable（最顶层：可遍历） ↓ 继承 Collection（通用集合：增删改查） ↓ 继承 List / Set / Queue（三大分支，各有特性） ↓ 实现 ArrayList / LinkedList / HashSet...（具体实现类）
每一层接口只定义自己这一层该有的能力，下层自动继承上层的所有方法。
1. 最顶层：Iterable 接口 —— 定义「能被遍历」的能力
-
职责：只要实现了这个接口，就代表「这个东西可以被循环遍历」。
-
原生核心方法：
iterator()—— 返回一个迭代器，用来逐个取元素。 -
Java 8 新增默认方法：
forEach()这就是你看到的fruits.forEach()的来源！
因为 Iterable 是所有集合的顶层父接口，所以所有 List、Set 集合天生就带 forEach 方法，不是 ArrayList 自己写的，是从最顶层继承下来的。
-
设计目的：把「循环遍历每个元素」的模板代码统一封装好，使用者只需要传「每个元素做什么」的逻辑。
-
方法参数：
Consumer<T>函数式接口 → 所以可以传 Lambda 表达式。
2. 第二层：Collection 接口 —— 定义所有集合的通用能力
-
职责：定义所有集合都具备的基础操作，和具体是 List 还是 Set 无关。
-
核心方法（你天天会用到）：
-
add()/remove()/clear()：增删 -
size()/isEmpty()/contains()：查询判断 -
toArray()：转数组
-
这些方法所有集合都有，就是因为继承自 Collection。
3. 第三层：List 接口 —— 有序、可重复集合的专属能力
-
职责：在通用集合能力之上，增加「有序、按索引访问」的专属特性。
-
特有方法：
-
get(int index)/set(int index, E element)：按索引读写 -
add(int index, E element)：按位置插入 -
sort(Comparator c)：Java 8 新增，自己就可以排序
-
也就是说，从 Java 8 开始，List 自己就带 sort 方法了，你可以直接写 fruits.sort(比较器)，不一定非要用 Collections.sort。
4. 第四层：具体实现类 —— 真正落地的容器
比如 ArrayList、LinkedList、HashSet，它们负责把上面接口定义的方法真正实现出来，各自用不同的数据结构（数组、链表、哈希表），性能特点不同。
三、第二大类：Collections 工具类 —— 集合的「公共工具箱」
1. 它是什么
java.util.Collections 是一个纯静态工具类（构造方法私有，不能实例化），它自己不存任何数据，专门给各类集合提供通用的、公共的操作方法。
2. 为什么要单独搞一个工具类？
这是早期 Java 的设计习惯：
-
接口只能定义方法声明，不能写实现代码（Java 8 之前没有 default 方法）
-
很多操作是所有 List 通用的（比如排序、反转、找最大值），如果每个实现类都写一遍，代码严重重复
-
所以把这些通用操作抽出来，做成一个公共工具类，所有集合都可以调用
这就是 Collections.sort() 的由来 —— 它不是集合的方法，是工具箱里专门给 List 做排序的工具函数。
3. Collections 里常用的方法（都是静态方法，调用格式统一）
Collections.方法名(集合, 可选参数)
常用的几类：
-
排序相关：
sort()、reverse()（反转）、shuffle()（打乱顺序） -
查找极值：
max()、min() -
替换填充：
fill()、replaceAll() -
安全相关：
synchronizedList()（把普通集合变成线程安全的）
4. 补充：Collections.sort 和 List.sort 的关系
Java 8 之后 List 自己加了 sort 默认方法，两者的关系是：
-
老写法：
Collections.sort(list, 比较器) -
新写法：
list.sort(比较器) -
底层关系：现在
Collections.sort内部其实就是直接调用list.sort()，属于兼容老代码的历史写法
四、把你问的两个方法放回体系里
1. fruits.forEach()
-
归属：
Iterable接口的默认方法，被 List 继承下来 -
为什么会有：Java 8 为了配合函数式编程，给最顶层的可遍历接口统一增加了遍历方法，避免每个集合自己写循环
-
参数为什么能写 Lambda：方法参数是
Consumer<T>函数式接口，符合单抽象方法规则
2. Collections.sort()
-
归属：
Collections工具类的静态方法 -
为什么会有：早期 Java 接口不能写实现，排序这种通用操作只能放在工具类里，是历史遗留的经典写法
-
参数为什么能写 Lambda：第二个参数是
Comparator<T>函数式接口
五、新手学习的体系化顺序建议
按这个顺序学，就不会觉得知识点是零散冒出来的：
-
先记整体继承树：
Iterable → Collection → List/Set → 实现类 -
学每层接口的核心职责和常用方法（从上往下学）
-
学
Collections工具类的通用操作 -
学 Java 8 新增：forEach、List.sort、Stream 流
-
最后深入每个实现类的底层数据结构和性能区别
六、一个最容易搞混的点再强调一遍
-
Collection（单数）：是集合的顶层父接口，代表「集合」这个抽象概念 -
Collections（复数，带 s）：是操作集合的工具类，全是静态方法
Java List 集合常用方法分类速查清单
下面直接为你整理好完整的速查内容，每个方法同时标注它在集合继承体系中的归属，呼应前面讲的层级逻辑：
一、增：添加元素（2 个）
-
boolean add(E e)-
归属：
Collection接口（所有集合通用） -
作用：在集合末尾追加一个元素
-
示例：
fruits.add("grape");
-
-
void add(int index, E element)-
归属：
List接口（List 特有，有序集合才有索引） -
作用：在指定索引位置插入元素，后续元素整体后移
-
示例：
fruits.add(1, "mango");
-
二、删：删除元素（3 个）
-
E remove(int index)-
归属：
List接口 -
作用：删除指定索引位置的元素，返回被删除的元素
-
示例：
fruits.remove(0);
-
-
boolean remove(Object o)-
归属：
Collection接口 -
作用：删除集合中第一个匹配的指定元素，删除成功返回 true
-
示例：
fruits.remove("apple");
-
-
void clear()-
归属：
Collection接口 -
作用：清空集合中所有元素
-
示例：
fruits.clear();
-
三、改：修改元素（1 个）
-
E set(int index, E element)-
归属：
List接口 -
作用：替换指定索引位置的元素，返回被替换的旧元素
-
示例：
fruits.set(0, "peach");
-
四、查：查询与判断（3 个）
-
E get(int index)-
归属：
List接口 -
作用：根据索引获取对应位置的元素
-
示例：
String first = fruits.get(0);
-
-
int size()/boolean isEmpty()-
归属：
Collection接口 -
作用：分别获取集合元素个数、判断集合是否为空
-
示例：
int num = fruits.size(); boolean empty = fruits.isEmpty();
-
-
boolean contains(Object o)-
归属：
Collection接口 -
作用：判断集合中是否包含指定元素
-
示例：
boolean hasApple = fruits.contains("apple");
-
五、遍历：循环处理元素（1 个）
-
void forEach(Consumer<? super E> action)-
归属：
Iterable接口（最顶层，所有可遍历集合通用） -
作用：遍历集合每个元素，执行自定义逻辑，支持 Lambda 表达式
-
示例：
fruits.forEach(s -> System.out.println(s));
-
六、排序：自定义排序（1 个）
-
void sort(Comparator<? super E> c)-
归属：
List接口（Java 8 新增默认方法） -
作用：按指定比较规则对集合元素排序
-
示例：
fruits.sort((s1, s2) -> s1.length() - s2.length());
-
以上方法覆盖了 List 绝大多数日常操作，其中标注「Collection 归属」的方法，Set 等其他集合也同样拥有；标注「List 归属」的，只有 List 系列有序集合可以使用。
lambda 举例
List<String> list = new ArrayList<>(List.of("apple", "banana", "pear", "orange"));
list.sort(new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
// 升序：前减后；降序反过来
return s1.length() - s2.length();
}
});
list.sort((String s1, String s2) -> {
return s1.length() - s2.length();
});
练习题
1.排序comparator接口
package APIlearn;
import java.util.Arrays;
import java.util.Comparator;
public class test10 {
public static void main(String[] args) {
Boys b1=new Boys("zhang",19,178);
Boys b3=new Boys("wang",20,179);
Boys b2=new Boys("li",30,189);
Boys[] arr={b1,b2,b3};
//
// Arrays.sort(arr,new Comparator<Boys>(){
// @Override
// public int compare(Boys bb1,Boys bb2){
// double temp=bb1.getAge()-bb2.getAge();
// temp= temp ==0? bb1.getHeight()-bb2.getHeight() : temp ;
//
// temp=temp==0?bb1.getName().compareTo(bb2.getName()):temp;
//
//
// if(temp>0)return 1;
// else if(temp<0)return -1;
// else return 0;
//
// }
//
//
// });
//
// Arrays.sort(arr,(Boys bb1,Boys bb2)->{
// double temp=bb1.getAge()-bb2.getAge();
// temp= temp ==0? bb1.getHeight()-bb2.getHeight() : temp ;
//
// temp=temp==0?bb1.getName().compareTo(bb2.getName()):temp;
//
//
// if(temp>0)return 1;
// else if(temp<0)return -1;
// else return 0;
//
//
//
//
// });
Arrays.sort(arr,(bb1, bb2)->{
double temp=bb1.getAge()-bb2.getAge();
temp= temp ==0? bb1.getHeight()-bb2.getHeight() : temp ;
temp=temp==0?bb1.getName().compareTo(bb2.getName()):temp;
if(temp>0)return 1;
else if(temp<0)return -1;
else return 0;
});
System.out.println(Arrays.toString(arr));
}
}
2.神兔
package APIlearn;
public class tset11 {
public static void main(String[] args) {
// int [] arr=new int[12];
// arr[0]=1;
// arr[1]=1;
// for (int i = 2; i < arr.length; i++) {
// arr[i]=arr[i-1]+arr[i-2];
// }
// System.out.println(arr[11]);
//递归的方法
//1.递归的出口
//2.找到递归的规律
//Fn(12)=Fn(10)+Fn(11)
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);
}
}
3.递归
package APIlearn;
public class test12 {
public static void main(String[] args) {
System.out.println(getCount(1));
}
public static int getCount(int day){
if(day>=11 ||day<=0){
System.out.println("时间错误");
return -1;
}
//递归的出口
if(day==10){
return 1;
}
return (getCount(day+1)+1)*2;
}
}
更多推荐
7
0- 0
已为社区贡献1条内容
所有评论(0)