声明：该专栏本人重新过一遍java知识点时候的笔记汇总，主要是每天的知识点+题解，算是让自己巩固复习，也希望能给初学的朋友们一点帮助，大佬们不喜勿喷(抱拳了老铁！)
因为个人原因断更了一段时间，从今天开始补上。
往期回顾
Java学习day15：Object类、set集合（知识点＋例题详解）_java set集合编程题-CSDN博客
Java学习day16：内部类、map集合
一、内部类
在类的内部创建一个类，这个类叫内部类。
1.1匿名内部类
为什么用匿名内部类：为了减少代码量
一般接口用匿名内部类，往往是这个接口只有一个抽象方法，不是说所有的抽象类和接口都可以这么用
1.1.1基于抽象类的匿名内部类
我们先来看常规的抽象类方法的写法：
重新创建一个类去继承抽象类并实现，然后在主函数里new这个类的对象，并调用相应方法。
示例：
abstract class Person{
public abstract void eat();
public void drink(){
System.out.println("hehehehhehe!!!");
}
}
//常规写法，重新创建一个类去继承抽象类并实现，然后在主函数里new这个类的对象
class Man extends Person {
@Override
public void eat() {
System.out.println("chichicihchic!!!");
}
}
public class Main {
public static void main(String[] args) {
Man man = new Man();
man.eat();
man.drink();
}我们再来看匿名类的写法：
示例：
abstract class Person{
public abstract void eat();
public void drink(){
System.out.println("hehehehhehe!!!");
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person() {
@Override
public void eat() {
System.out.println("吃吃吃吃吃吃!!!");
}
};
person.eat();
person.drink();
}相当于是直接对抽象类new对象并把抽象方法写进去，然后直接用对象调用。
改进一下，来一个更快的
示例：
abstract class Person{
public abstract void eat();
public void drink(){
System.out.println("hehehehhehe!!!");
}
}
public class Main {
public static void main(String[] args) {
new Person(){
@Override
public void eat() {
System.out.println("吃吃吃吃吃！！！");
}
}.eat();
}这次连对象都创建了，直接new了调用方法就是。
这样写确实节约，直接少了一个类，但是坏处就是，只能调用一个方法，这个是一次性的，如果需要调用多个方法，就还需要写new的部分，比不上有对象调用。
1.1.2基于接口的匿名内部类
跟基于抽象类的是一样的，只是说改成了接口，而且同样的有快捷写法，写一个示例大家秒懂：
interface A {
void testA();
}
public class Demo3 {
public static void main(String[] args) {
// A a = new A(){
//
// @Override
// public void testA() {
// System.out.println("嘻嘻哒");
// }
// };
// a.testA();
new A(){
@Override
public void testA() {
System.out.println("哈哈");
}
}.testA();
}
}这个时候，联想我们上面写的Treeset集合里比较器的用法，比较器也是一个抽象类，我们完全可以对比较器用匿名内部类
示例：
import java.util.Comparator;
import java.util.TreeSet;
import java.util.Set;
class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Demo4 {
//存到TreeSet里面
public static void main(String[] args) {
Set<Student> set = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int num = o1.age - o2.age;
return num;
}
});
set.add(new Student("维一", 23));
set.add(new Student("永康", 19));
set.add(new Student("赵娜", 18));
set.add(new Student("运铎", 28));
set.add(new Student("佳祥", 36));
System.out.println(set);
}
}而真实开发的时候，就是一个方法参数是一个接口对象，不用再新建一个类去实现这个接口，直接方法中去new 接口
示例：
interface B {
void eat();
}
public class Demo5 {
public static void main(String[] args) {
test(new B() {
@Override
public void eat() {
System.out.println("吃锦旗");
}
});
}
public static void test (B b) {
b.eat();
}
}1.2成员内部类
在类的方法的外面，在类中，就是成员内部类。
这个基本不会用，大家看一个示例，知道语法格式，以后遇到看得懂代码就OK。
class MemberDemo {
String name = "张三";
int age = 20;
public void printf() {
System.out.println("打印着玩");
}
class Inner {//就是内部类
String name = "李四";
//在Inner这个类中可以访问外部类的属性和方法
public void test () {
printf();//打印着玩
System.out.println(age);//20
System.out.println(name);//李四
//如果访问外部特定的属性的时候: 类名.this.属性
System.out.println(MemberDemo.this.name);//张三
}
}
}
public class Demo1 {
public static void main(String[] args) {
//成员内部类的创建步骤：
//1.实例化外部类 类对象
MemberDemo memberDemo = new MemberDemo();
//2.实例化内部类对象，但是new得改为 外部对象.new
MemberDemo.Inner inner = memberDemo.new Inner();
inner.test();
}
}二、map集合
地图， 通过一个点可以找到一个具体的位置。是一种映射。
map集合也是存数据的,双边队列。
语法结构：
Interface Map<K,V>
k: key 键
v: value 值
首先来说map是一个接口，其次我们存的是key和value，称之为键值对
记住，map集合中存的数据是键值对形式的数据。比如：｛0001=家豪， 002=志成， 003=王腾飞｝ 0001是键，家豪是值 。
同样的。map集合也是两个实现类：1.HashMap、2.TreeMap。
2.1Map集合中常用的方法
| 增： | V put(K key, V vlaue);添加键值对的数据到map集合中 | void putAll(Map<? extends K> k, Map<? extends V> v);将一个map集合存放到另外一个map集合中 |
| 删: | V remove (K key);通过键删除键值对的数据，返回值是值 | |
| 改： | V put(K key V value);当键值存在的时候，会将value值覆盖掉的 | |
| 查: | int size(); 查看集合中元素的个数 boolean isEmpty();判断是否为空，如果不为空返回的是false boolean containsKey();是否包含这个键 boolean containsValue();是否包含这个值 |
重要的方法:
V get(K key);通过键获取值
Set<K> keySet();获取map集合中的键，然后存到set集合中
Collection<V> values(); 获取map集合中值，存到了Collection集合中
Set<Map.Entry<K,V>> entrySet()；将map集合的键值对，存到了set集合
Map.Entry这个接口的方法
getKey:返回键值对的键
getValue:返回键值对的值
方法有点多，需要记忆一下，但是都很简单，我们举一个简单例子来看一看。
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo1 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("002", "老邢");
map.put("001", "骚磊");
map.put("003", "老万");
//{001=老邢, 002=骚磊, 003=老万}
System.out.println(map);
//键必须是唯一的，因为底层使用的hash算法的操作
//value值是会被替换的，当键一样的时候
map.put("002", "二贝");
System.out.println(map);
Map<String, String> map1 = new HashMap<>();
map1.put("004", "小邢");
map1.put("005", "小骚磊");
map1.put("006", "小老万");
map.putAll(map1);
System.out.println(map);
//{001=骚磊, 002=二贝, 003=老万, 004=小邢, 005=小骚磊, 006=小老万}
System.out.println(map.remove("001"));//骚磊
System.out.println(map);//删除完以后，看看还有咩有这个键值对
map.put("006", "小小万");//修改
System.out.println(map);
//查询
System.out.println(map.size());//5
System.out.println(map.isEmpty());//false
System.out.println(map.containsKey("002"));//true
System.out.println(map.containsValue("大狗蛋"));//false
//获取所有的键 存到set集合中了
Set<String> strings = map.keySet();
System.out.println(strings);
Collection<String> values = map.values();
System.out.println(values);
//entrySet
Set<Map.Entry<String, String>> entries = map.entrySet();
System.out.println(entries);
//将数据取出来
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry);
System.out.println(entry.getKey());
System.out.println(entry.getValue());
System.out.println("--------");
}
}
}大家可以发现其实有很多种取键取值的方法，但是开发中用的最多的，就是entries的增强for循环。
注意，键值是唯一的，而value值可以被覆盖，
这也是为什么Set<K> keySet();获取map集合中的键，然后存到set集合中
因为set集合也是唯一的
2.2Map集合中的value
存的是对象，还可以存list集合，集合里再存对象，取的时候，用entries的双层for循环
import java.util.*;
class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Demo2 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student("张三", 24));
list.add(new Student("狗蛋", 26));
list.add(new Student("财运", 28));
list.add(new Student("彩云", 23));
List<Student> list1 = new ArrayList<>();
list1.add(new Student("二贝", 24));
list1.add(new Student("老邢", 26));
list1.add(new Student("秦始皇", 28));
list1.add(new Student("汉武帝", 23));
Map<String, List<Student>> map1 = new HashMap<>();
map1.put("001", list);
map1.put("002", list1);
//以上在存值
//取值
Collection<List<Student>> values1 = map1.values();
for (List<Student> students : values1) {
for (Student student : students) {
System.out.println(student.name);
}
}
System.out.println("======");
Map<Integer, Student> map = new HashMap<>();
map.put(1, new Student("张三", 24));
map.put(2, new Student("张三", 24));
map.put(3, new Student("狗蛋", 26));
map.put(4, new Student("李四", 21));
System.out.println(map);
//以上存值
//取值
//取键
Set<Integer> key = map.keySet();
System.out.println(key);
Collection<Student> values = map.values();
System.out.println(values);
for (Student value : values) {
System.out.println(value.name);
}
System.out.println("=====");
//使用entrySet
Set<Map.Entry<Integer, Student>> entries = map.entrySet();
for (Map.Entry<Integer, Student> entry : entries) {
System.out.println(entry.getValue().name);
}
}
}总结：
2.Map下面的方法
Map<String, String> map = new HashMap<>();
增：
put(K key, V value)
putAll();
删：
remove(K key); 通过键删除值
改：
put(K key, V value) 只要键存在的话就是会修改值
查：
size()
containsKey();
containsValue();
keySet() 获取集合中的键 存到set集合中
values() 获取集合中的值 存到Collection集合中
entrySet() 将一个键值对 封装一个entry 存到咱们的set集合中
可以自己百度看一下，看看能不能看懂！jdk 1.8的 HashMap源码 底层
开发中用
List==》ArrayList
Map===>HashMap
以上，就是今天的所有知识点了。内部类用的不多，主要是熟悉语法，大家看到的时候要知道，Map集合是重点，其中得常用方法比较多，大家得多花点时间，静下心记忆一下，不是什么大问题。另外大家可以下来自行再拓展 HashMap源码 底层。
加油吧，预祝大家变得更强！
扫一扫
396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
