java List

最新推荐文章于 2024-04-07 22:01:10 发布

bobob_

最新推荐文章于 2024-04-07 22:01:10 发布

阅读量137

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/dubo_csdn/article/details/86610814

版权

java 专栏收录该内容

85 篇文章 1 订阅

订阅专栏

###15.01_集合框架(去除ArrayList中重复字符串元素方式)(掌握)

* A:案例演示

* 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)

* 思路：创建新集合方式

案例:

@SuppressWarnings({ "rawtypes", "unchecked" })

public class Demo1_ArrayList {

public static void main(String[] args) {

ArrayList list = new ArrayList();

list.add("a");

list.add("b");

list.add("c");

ArrayList newList = getSingle(list);

System.out.println(newList);

}

* 创建新集合将重复元素去掉

* 1,明确返回值类型,返回ArrayList

* 2,明确参数列表ArrayList

* 分析:

* 1,创建新集合

* 2,根据传入的集合(老集合)获取迭代器

* 3,遍历老集合

* 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加

public static ArrayList getSingle(ArrayList list) {

ArrayList newList = new ArrayList(); //1,创建新集合

Iterator it = list.iterator(); //2,根据传入的集合(老集合)获取迭代器

while(it.hasNext()) { //3,遍历老集合

Object obj =it.next(); //记录住每一个元素

if(!newList.contains(obj)) { //如果新集合中不包含老集合中的元素

newList.add(obj); //将该元素添加

}

return newList;

}

###15.02_集合框架(去除ArrayList中重复自定义对象元素)(掌握)

* A:案例演示

* 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)

* B:注意事项

* 重写equals()方法的

案例:

@SuppressWarnings({ "rawtypes", "unchecked" })

public class Demo2_ArrayList {

/**

* * A:案例演示

* 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同,即同姓名同年龄)

* B:注意事项

* 重写equals()方法的

contains方法判断是否包含,底层依赖的是equals方法

remove方法判断是否删除,底层依赖的是equals方法

public static void main(String[] args) {

ArrayList list = new ArrayList(); //创建集合对象

list.add(new Person("张三", 23));

list.add(new Person("李四", 24));

//ArrayList newList = getSingle(list); //调用方法去除重复

//System.out.println(newList);

list.remove(new Person("张三", 23));

System.out.println(list);

}

* 创建新集合将重复元素去掉

* 1,明确返回值类型,返回ArrayList

* 2,明确参数列表ArrayList

* 分析:

* 1,创建新集合

* 2,根据传入的集合(老集合)获取迭代器

* 3,遍历老集合

* 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加

public static ArrayList getSingle(ArrayList list) {

ArrayList newList = new ArrayList<>(); //1,创建新集合

Iterator it = list.iterator(); //2,根据传入的集合(老集合)获取迭代器

while(it.hasNext()) { //3,遍历老集合

Object obj =it.next(); //记录住每一个元素

if(!newList.contains(obj)) { //如果新集合中不包含老集合中的元素

newList.add(obj); //将该元素添加

}

return newList;

}

实体类:

public class Person {

private String name;

private int age;

public Person() {

super();

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return "Person [name=" + name + ", age=" + age + "]";

}

/*@Override

public boolean equals(Object obj) {

Person p = (Person)obj;

System.out.println("equals 方法被调用了,证明contains方法底层调用的是equals");

return this.name.equals(p.name) && this.age == p.age;

}*/

}

###15.03_集合框架(LinkedList的特有功能)(掌握)

* A:LinkedList类概述

* B:LinkedList类特有功能

* public void addFirst(E e)及addLast(E e)

* public E getFirst()及getLast()

* public E removeFirst()及public E removeLast()

* public E get(int index);

案例:

public class Demo3_LinkedList {

public static void main(String[] args) {

LinkedList list = new LinkedList();

list.addFirst("a");

list.addFirst("b");

list.addFirst("c");

list.addFirst("d");

list.addLast("e");

//System.out.println(list.getFirst());

//System.out.println(list.getLast());

//System.out.println(list.removeFirst());

//System.out.println(list.removeLast());

System.out.println(list.get(1));

System.out.println(list);

}

/*dcbae*/

}

###15.04_集合框架(栈和队列数据结构)(掌握)

* 栈

* 先进后出

* 队列

* 先进先出

###15.05_集合框架(用LinkedList模拟栈数据结构的集合并测试)(掌握)

* A:案例演示

* 需求：请用LinkedList模拟栈数据结构的集合，并测试

* 创建一个类将Linked中的方法封装

案例:

public class Demo4_LinkedList {

/**

* 用LinkedList模拟栈结构

public static void main(String[] args) {

demo1();

}

public static void demo1() {

LinkedList list = new LinkedList(); //创建集合对象

list.addLast("a");

list.addLast("b");

list.addLast("c");

list.addLast("d");

/*System.out.println(list.removeLast());

System.out.println(list.removeLast());

System.out.println(list.removeLast());*/

while(!list.isEmpty()) {

System.out.println(list.removeLast());

}

自定义Stack类:

package com.heima.list;

import java.util.LinkedList;

public class Stack {

private LinkedList list = new LinkedList();

* 模拟进栈方法

public void in(Object obj) {

list.addLast(obj);

}

* 模拟出栈

public Object out() {

return list.removeLast();

}

* 模拟栈结构是否为空

public boolean isEmpty() {

return list.isEmpty();

}

测试自定义的Stack类:

public class Demo4_LinkedList {

/**

* 用LinkedList模拟栈结构

public static void main(String[] args) {

Stack s = new Stack();

s.in("a"); //进栈

s.in("b");

s.in("c");

s.in("d");

while(!s.isEmpty()) { //判断栈结构是否为空

System.out.println(s.out()); //弹栈

}

###15.06_集合框架(泛型概述和基本使用)(掌握)

* A:泛型概述:限定集合存储的数据类型,Collection<E>其中E代表引用数据类型,如果加上了该引用数据类型,表示该集合中只能存储改类型对象,或者该类型的子类对象.

* B:泛型好处

* 提高安全性(将运行期的错误转换到编译期)

* 省去强转的麻烦

* C:泛型基本使用

* <>中放的必须是引用数据类型

* D:泛型使用注意事项

* 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)

案例:

public class Demo1_Generic {

public static void main(String[] args) {

//demo1();

//int[] arr = new byte[5]; //数组要保证前后的数据类型一致

//ArrayList<Object> list = new ArrayList<Person>(); //集合的泛型要保证前后的数据类型一致

//ArrayList<Object> list = new ArrayList<>(); //1.7版本的新特性,菱形泛型,前面定义了,后面不加表示和前面一致

ArrayList<Object> list = new ArrayList<>(); //泛型最好不要定义成Object,没有意义

list.add("aaa");

list.add(true);

}

public static void demo2() {

ArrayList<Person> list = new ArrayList<Person>();

// list.add(110);

// list.add(true);

list.add(new Person("张三", 23));

list.add(new Person("李四", 24));

Iterator<Person> it = list.iterator();

while(it.hasNext()) {

//System.out.println(it.next());

//System.out.println(it.next().getName() + "..." + it.next().getAge());//next方法只能调用一次,如果调用多次会将指针向后移动多次

Person p = it.next();

System.out.println(p.getName() + "..." + p.getAge());

}

public static void demo1() {

//这里编译通过,运行包ClassCastException(类转换异常)

ArrayList list = new ArrayList();

list.add(110);

list.add(true);

list.add(new Person("张三", 23));

list.add(new Person("李四", 24));

Iterator it = list.iterator();

while(it.hasNext()) {

Person p = (Person)it.next();

System.out.println(p.getName() + "..." + p.getAge());

}

###15.07_集合框架(ArrayList存储字符串和自定义对象并遍历泛型版)(掌握)

* A:案例演示

* ArrayList存储字符串并遍历泛型版

案例:

public class Demo2_Generic {

/**

* * A:案例演示

* ArrayList存储字符串并遍历泛型版

public static void main(String[] args) {

//demo1();

//demo2();

demo3();

}

private static void demo3() {

ArrayList<Person> list = new ArrayList<>();

list.add(new Person("张三", 23));

list.add(new Person("李四", 24));

list.add(new Person("王五", 25));

list.add(new Person("赵六", 26));

//使用高级for循环进行遍历

for(Person person :list) {

System.out.println(person.getName()+"...."+person.getAge());

}

private static void demo2() {

ArrayList<Person> list = new ArrayList<>();

list.add(new Person("张三", 23));

list.add(new Person("李四", 24));

list.add(new Person("王五", 25));

list.add(new Person("赵六", 26));

Iterator<Person> it = list.iterator();

while(it.hasNext()) {

Person p = it.next(); //将集合中的每一个元素用Person记录

System.out.println(p.getName() + "..." + p.getAge());

}

public static void demo1() {

ArrayList<String> list = new ArrayList<>(); //创建集合对象

list.add("a");

list.add("b");

list.add("c");

list.add("d");

Iterator<String> it = list.iterator();

while(it.hasNext()) {

System.out.println(it.next());

}

###15.08_集合框架(泛型的由来)(了解)

* A:案例演示

* 泛型的由来:通过Object转型问题引入

* 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

案例:

实体类Student

public class Student extends Person {

public Student() {

}

public Student(String name, int age) {

super(name, age);

}

实体类Worker:

public class Worker extends Person {

public Worker() {

}

public Worker(String name, int age) {

super(name, age);

}

工具类Tool:

public class Tool {

private Object obj;

public Object getObj() {

return obj;

}

public void setObj(Object obj) {

this.obj = obj;

}

测试类:

public class Demo3_Generic {

/**

* A:案例演示

* 泛型的由来:通过Object转型问题引入

* 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

public static void main(String[] args) {

Tool t = new Tool();//创建工具类对象

t.setObj(new Student("张三",23));//存入的是Student

Worker worker = (Worker)t.getObj();//获取的时候转成了Worker,但是编译时不报错,运行时报ClassCastException

}

###15.09_集合框架(泛型类的概述及使用)(了解)

* A:泛型类概述<T>

* 把泛型定义在类上

* B:定义格式

* public class 类名<泛型类型1,…>

* C:注意事项

* 泛型类型必须是引用类型

* D:案例演示

* 泛型类的使用

案例(使用上个案例中的实体类):

public class Tool<Q> {//在类上定义了泛型Q,Q什么时候有值,当你用这个类时,指定了泛型是什么,Q就代表什么

private Q q;

public Q getObj() {

return q;

}

public void setObj(Q q) {

this.q = q;

}

测试类:

public class Demo3_Generic {

/**

* A:案例演示

* 泛型的由来:通过Object转型问题引入

* 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

public static void main(String[] args) {

demo1();

}

public static void demo1() { //创建工具类对象

t.setObj(new Student("张三",23));

Tool<Student> t = new Tool<>();

Student s = t.getObj(); //因为使用了泛型,存入的是啥,取出的就是啥,不用向下转型

System.out.println(s);

}

###15.10_集合框架(泛型方法的概述和使用)(了解)

* A:泛型方法概述

* 把泛型定义在方法上

* B:定义格式(方法上单独定义泛型,要在权限修饰符后面返回值类型的前面)

* public <泛型类型> 返回类型方法名(泛型类型变量名) //方法泛型最好和类的泛型一致,如果不一致，需要在方法上声明访泛型 public<T> void show(T,t){};

* C:案例演示

* 泛型方法的使用

public class Tool<Q> {//在类上定义了泛型Q,Q什么时候有值,当你用这个类时,指定了泛型是什么,Q就代表什么

private Q q;

public Q getObj() {

return q;

}

public void setObj(Q q) {

this.q = q;

}

public void write(Q q){ //write方法使用类上定义的泛型

System.out.println(q);

}

public <T> void show(T t) { //方法泛型最好与类的泛型一致

System.out.println(t); //如果不一致,需要在方法上声明该泛型

}

//静态方法不能使用类上定义的泛型,必须单独定义

//因为静态方法随着类的加载而加载,在类加载后,可能还没有创建对象呢,所以此时静态方法上的泛型可能没值

public static<W> void print(W w) { //静态方法必须声明自己的泛型

System.out.println(w);

}

public class Demo3_Generic {

public static void main(String[] args) {

Tool<String> t = new Tool<>();

//t.write("abc");

t.show(true);

}

###15.11_集合框架(泛型接口的概述和使用)(了解)

* A:泛型接口概述

* 把泛型定义在接口上

* B:定义格式

* public interface 接口名<泛型类型>

* C:案例演示

* 泛型接口的使用

案例:

public class Demo4_Generic {

public static void main(String[] args) {

}

interface Inter<T> {

public void show(T t);

}

/*class Demo implements Inter<String> { //推荐用这种,实现接口的时候就指定了泛型

@Override

public void show(String t) {

System.out.println(t);

}

}*/

class Demo<T> implements Inter<T> { //没有必要在实现接口的时候给自己类加泛型

@Override

public void show(T t) {

System.out.println(t);

}

###15.12_集合框架(泛型高级之通配符)(了解)

* A:泛型通配符<?>:右边是不确定泛型时,左边可以用通配符?

* 任意类型，如果没有明确，那么就是Object以及任意的Java类了

? extends E ？是子类E是父类向下限定，E及其子类

? super E 向上限定，E及其父类

案例:

public class Demo5_Generic {

public static void main(String[] args) {

//当右边的类型不确定时,左边可以用通配符?

//List<?> list = new ArrayList<String>();

//List<?> list = new ArrayList<Integer>(); //当右边的泛型是不确定时,左边可以指定为?

//List<Object> list = new ArrayList<String>();//左右泛型的类型不一致

ArrayList<Person> list1 = new ArrayList<>();

list1.add(new Person("张三", 23));

list1.add(new Person("李四", 24));

list1.add(new Person("王五", 25));

ArrayList<Student> list2 = new ArrayList<>();

list2.add(new Student("赵六", 26));

list2.add(new Student("周七", 27));

//addAll方法的定义addAll(Collection<? extends E> c),也就是说调用addAll可以添加E及其子类型

//因为我们用list1调用的addAll方法,而list1中存放的是Person类,此时E就代表Person,所以可以添加Person类及其所有的子类型

//正好Student类是Person的子类可以添加

list1.addAll(list2);

//这样添加就报错了,因为Student是Person的子类,而不是Person是Student的子类

//list2.addAll(list1);

System.out.println(list1);

}

###15.13_集合框架(增强for的概述和使用)(掌握)

* A:增强for概述

* 简化数组和Collection集合的遍历,输入fore,之后alt+/提示后自动补全

* B:格式：

for(元素数据类型变量 : 数组或者Collection集合) {

使用变量即可，该变量就是元素

}

* C:案例演示

* 数组，集合存储元素用增强for遍历

* D:好处

* 简化遍历

案例:

public class Demo1_Foreach {

public static void main(String[] args) {

demo1();

}

public static void demo1() {

//基本数据类型数组的遍历

int[] arr = {11,22,33,44,55};

for (int i : arr) {

System.out.println(i);

}

//集合的遍历

ArrayList<String> list = new ArrayList<>();

list.add("a");

list.add("b");

list.add("c");

list.add("d");

for (String string : list) {

System.out.println(string);

}

###15.14_集合框架(ArrayList存储字符串和自定义对象并遍历增强for版)(掌握)

* A:案例演示

* ArrayList存储字符串并遍历增强for版

ArrayList<String> list = new ArrayList<>();

list.add("a");

list.add("b");

list.add("c");

list.add("d");

for(String s : list) {

System.out.println(s);

}

案例:

public class Demo1_Foreach {

public static void main(String[] args) {

demo2();

}

public static void demo2() {

ArrayList<Person> list = new ArrayList<>();

list.add(new Person("张三", 23));

list.add(new Person("李四", 24));

list.add(new Person("王五", 25));

list.add(new Person("赵六", 26));

for (Person person : list) {

System.out.println(person);

}

public static void demo1() {

int[] arr = {11,22,33,44,55};

for (int i : arr) {

System.out.println(i);

}

ArrayList<String> list = new ArrayList<>();

list.add("a");

list.add("b");

list.add("c");

list.add("d");

for (String string : list) {

System.out.println(string);

}

###15.15_集合框架(三种迭代的能否删除)(掌握)

* 普通for循环,可以删除,但是索引要--

* 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常

* 增强for循环不能删除

public class Demo1_Foreach {

private static ArrayList<String> list ;

//利用静态代码在加载类的时候就给list进行了初始化

static {

list = new ArrayList<>();

list.add("a");

list.add("b");

list.add("c");

list.add("d");

}

public static void main(String[] args) {

demo1();

}

public static void demo1() {

// ArrayList<String> list = new ArrayList<>();

// list.add("a");

// list.add("b");

// list.add("c");

// list.add("d");

// 1,普通for循环删除,索引要--

for (int i = 0; i < list.size(); i++) {

if ("b".equals(list.get(i))) {

list.remove(i--); // 通过索引删除元素,为了保证能删除连续相同的内容

}

System.out.println(list);

}

public static void demo2() {

// ArrayList<String> list = new ArrayList<>();

// list.add("a");

// list.add("b");

// list.add("c");

// list.add("d");

// 2,迭代器删除

Iterator<String> it = list.iterator();

while (it.hasNext()) {

if ("b".equals(it.next())) {

// list.remove("b"); //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常

it.remove();

}

System.out.println(list);

}

public static void demo3() {

// ArrayList<String> list = new ArrayList<>();

// list.add("a");

// list.add("b");

// list.add("c");

// list.add("d");

for (Iterator<String> it2 = list.iterator(); it2.hasNext();) {

if ("b".equals(it2.next())) {

// list.remove("b"); //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常

it2.remove();

}

System.out.println(list);

}

public static void demo4() {

// ArrayList<String> list = new ArrayList<>();

// list.add("a");

// list.add("b");

// list.add("c");

// list.add("d");

// 3,增强for循环,增强for循环不能删除,只能遍历

for (String string : list) {

if ("b".equals(string)) {

list.remove("b");

}

System.out.println(list);

}

###15.16_集合框架(静态导入的概述和使用)(了解，开发不用，能看懂即可)

* A:静态导入概述：导包指的是导入包中的类，而静态导入指的是导入包中的静态方法。

* B:格式：

* import static 包名….类名.方法名;

* 可以直接导入到方法的级别

* C:注意事项

* 方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?

这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

###15.17_集合框架(可变参数的概述和使用)(掌握)

* A:可变参数概述 ChangeableArgs

* 定义方法的时候不知道该定义多少个参数

* B:格式

* 修饰符返回值类型方法名(数据类型… 变量名){}

* C:注意事项：

* 这里的变量其实是一个数组

* 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个 (int j,int ... arr)

案例:

public class Demo3_ChangeableArgs {

public static void main(String[] args) {

int[] arr = {11,22,33,44,55};

//print(arr);

print(11,22,33,44,55);

System.out.println("---------------");

//print();

System.out.println("-----------------");

show(11,22,33,44,55);

}

/*public static void print(int[] arr) {

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

}*/

public static void show(int j,int ... arr) { //可变参数其实是一个数组

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

public static void print(int ... arr) { //可变参数其实是一个数组

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

###15.18_集合框架(Arrays工具类的asList()方法的使用)(掌握)

As.list（）数组转成集合

* A:案例演示

* Arrays工具类的asList()方法的使用

* Collection中toArray(T[] a)泛型版的集合转数组

案例:

public class Demo4_AsList {

/**

* 数组转换成集合

* 数组转换成集合虽然不能增加或减少元素,但是可以用集合的思想操作数组,也就是说可以使用其他集合中的方法

public static void main(String[] args) {

//demo1();

//demo2();

//集合转数组,加泛型的

ArrayList<String> list = new ArrayList<>();

list.add("a");

list.add("b");

list.add("c");

list.add("d");

String[] arr = list.toArray(new String[10]); //当集合转换数组时,数组长度如果是小于等于集合的size时,转换后的数组长度等于集合的size

//如果数组的长度大于了size,分配的数组长度就和你指定的长度一样

for (String string : arr) {

System.out.println(string);

}

public static void demo2() {

//int[] arr = {11,22,33,44,55};

//List<int[]> list = Arrays.asList(arr); 基本数据类型的数组转换成集合,会将整个数组当作一个对象转换

//System.out.println(list);

Integer[] arr = {11,22,33,44,55}; //将数组转换成集合,数组必须是引用数据类型

List<Integer> list = Arrays.asList(arr);

System.out.println(list);

}

public static void demo1() {

String[] arr = {"a","b","c"};

List<String> list = Arrays.asList(arr); //将数组转换成集合

//list.add("d"); //不能添加

System.out.println(list);

}

###15.19_集合框架(集合嵌套之ArrayList嵌套ArrayList)(掌握)

* A:案例演示

* 集合嵌套之ArrayList嵌套ArrayList ArrayList<ArrayList<Person>> list = new ArrayList<>();

案例:

public class Demo5_ArrayListArrayList {

/**

* * A:案例演示

* 集合嵌套之ArrayList嵌套ArrayList

* 案例:

* 我们学科,学科又分为若个班级

* 整个学科一个大集合

* 若干个班级分为每一个小集合

public static void main(String[] args) {

ArrayList<ArrayList<Person>> list = new ArrayList<>();

ArrayList<Person> first = new ArrayList<>(); //创建第一个班级

first.add(new Person("杨幂", 30));

first.add(new Person("李冰冰", 33));

first.add(new Person("范冰冰", 20));

ArrayList<Person> second = new ArrayList<>();

second.add(new Person("黄晓明", 31));

second.add(new Person("赵薇", 33));

second.add(new Person("陈坤", 32));

//将班级添加到学科集合中

list.add(first);

list.add(second);

//用高级for循环遍历学科集合

for(ArrayList<Person> a : list) {

for(Person p : a) {

System.out.println(p);

}

System.out.println("-------------------");

Iterator<ArrayList<Person>> iterator = list.iterator();

while(iterator.hasNext()){

ArrayList<Person> subList = iterator.next();

Iterator<Person> subIterator = subList.iterator();

while(subIterator.hasNext()){

Person person = subIterator.next();

System.out.println(person);

}

contains 去重必须重写 equals方法

hascode 方法也可以重写equals

栈先进后出

队先进先出（管子）

泛型是引用数据类型

1.7新特性可以不加<> （菱形的新特性）

泛型最好不要定义Object,没有意义，（泛型就是规定本类的的类型）在有的时候出现<>菱括号时加

泛型就是种瓜得瓜

class Demo implements Inter<String>//推荐用这种

class Demo<T> implements Inter<T>

增强for

fore

for(int i : arr){

syso

}

for(string string : list){

syso

}

for(要遍历的数据类型变量名：要被遍历的数组或集合的对象)

注意并发异常

普通for循环要减减

jdk 1.5新特性静态导入

可变参数（int....arr）

Array.asList(arr) 数组转换成集合,数组必须用引用数据

bobob_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录