集合
概述
继承体系
Collection接口
概述
- 单列集合的顶层接口,它表示一组对象,这些对象也被称为Collection的元素
- JDK不提供此接口的任何直接实现,它提供更具体的子接口(如Set和List)实现
创建Collection集合的对象
Collection 集合常用方法
- boolean add(E e)添加元素
- boolean remove(Object o)从集合中移除指定的元素
- boolean removeif(Object o)根据条件进行删除
注意事项：
1.removeif括号中可以使用lambda表达式
2.removeif底层会遍历集合,得到集合中的每一个元素
3.底层会把每一个元素放到lambda表达式中去判断,true就删除
- void clear() 清空集合
- boolean contains(Object o)判断集合中是否存在指定的元素
- boolean isEmpty()判断集合是否为空
- int size0集合的长度,也就是集合中元素的个数
public class CollectionDemo2 {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
// - boolean add(E e)添加元素
collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
System.out.println(collection); // [aaa, bbb, ccc]
//- boolean remove(Object o)从集合中移除指定的元素
boolean result = collection.remove("aaa");
boolean result2 = collection.remove("ddd");
System.out.println(result); // true
System.out.println(result2); // false
System.out.println(collection); // [bbb, ccc]
//- boolean removeif(Object o) 根据条件进行删除
// 注意事项,removeif括号中可以使用lambda表达式
collection.removeIf((String s)->{
return s.length() == 3; // 删除字符串长度为三的字符串
});
System.out.println(collection);// []
collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
System.out.println(collection); // [aaa, bbb, ccc]
//- void clear()清空集合
collection.clear();
System.out.println(collection); // []
//- boolean contains(Object o)判断集合中是否存在指定的元素
collection.add("aaa");
System.out.println(collection.contains("aaa")); // true
System.out.println(collection.contains("ddd")); // false
//- boolean isEmpty()判断集合是否为空
System.out.println(collection.isEmpty()); // false
//- int size0集合的长度,也就是集合中元素的个数
System.out.println(collection.size()); // 1
}
}
Iterator
迭代器,集合专业遍历方式，是一个接口，我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊，Collection接口中有一个方法，叫Iterator(),这个方法返回的就是迭代器的实现类对象,Iterator<e> iterator()返回再此 collection 的元素上进行的迭代器。
使用步骤
1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)
2.使用Iterator接口当中的方法hasNext判断下还有没有下一个元素
3.使用Iterator接口中的方法next取出集合的下一个元素
常用方法:
public e next():返回迭代的下一个元素，取出元素后将迭代器往后移动一个索引
public boolean hasNext():如果仍有元素可以迭代，则返回true
default void remove():从底层集合中删除迭代器返回的最后一个元素(指向谁删除谁).
public class CollectionDemo3 {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<>();
//添加元素:
coll.add("串串星人");
coll.add("吐槽星人");
coll.add("汪星人");
//1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)
//注意：Iterator<E>接口也是由泛型的,迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
Iterator<String> it = coll.iterator();
//没有元素，在取出元素会抛出NoSuchElementException没有元素异常
while(it.hasNext()){
String e = it.next();
System.out.println(e);
}
while(it2.hasNext()){
String e = it2.next();
if("串串星人".equals(e)){
it.remove();
}
}
System.out.println("--------------------------------");
for(Iterator<String> it3 = coll.iterator();it3.hasNext();){
String e = it3.next();
System.out.println(e);
}
}
}
继承体系
List 接口
概述
- 有序的集合(存储和取出元素顺序相同)
- 允许存储重复元素。
- 有索引，可以使用普通的for循环遍历
常用方法
public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
E remove(int index)：删除指定索引处的元素,返回被删除的元素,也可以删除指定的元素
E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
E get(int index)：返回指定索引处的元素
public class Demo01List {
public static void main(String[] args) {
//创建一个List集合对象，多态
List<String> list = new ArrayList<>();
//使用add方法往集合中添加元素
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("a");
System.out.println(list);//[a,b,c,d,a]
//public void add(int index, E element)`: 将指定的元素，添加到该集合中的指定位置上。
//在c和d之间添加z
list.add(3,"z");
System.out.println(list); // [a, b, c, z, d, a]
// E remove(int index)：删除指定索引处的元素,返回被删除的元素,也可以删除指定的元素
list.remove(2);
System.out.println(list); //[a, b, z, d, a]
list.remove("d");
System.out.println(list); // [a, b, z, a]
//E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
list.set(0,"s");
System.out.println(list); //[s, b, z, d, a]
// E get(int index)：返回指定索引处的元素
System.out.println(list.get(list.size()-1)); //a
}
}
实现类
ArrayList底层
- ArrList底层数据是数组,查询快,增删慢
- 空参构造会创建一个长度为0的数组,当调用add方法会创建一个长度为10的数组,在底层叫做elementData,还会存在一个变量 size 它表达下一次要操作的索引,也表达数组元素的个数
- 如果数组填满,数组会自动扩容,创建一个长度1.5倍的数组
- 查询根据数组的地址址跟索引来获取,底层会判断你这个索引会不会大于等于size如果大于等于就报错
LinkedList
1.底层是一个链表结构，查询慢，增删快
2.里面包含了大量操作首尾元素的方法
public class LinkedListDemo1 {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("111");
linkedList.add("222");
linkedList.add("333");
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
for (String s : linkedList) {
System.out.println(s);
}
Iterator<String> iterator = linkedList.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
特有方法
- public void addFirst(E e)`:将指定元素插入此列表的开头。
- public void addLast(E e)`:将指定元素添加到此列表的结尾。
- public E getFirst()`:返回此列表的第一个元素。
- public E getLast()`:返回此列表的最后一个元素。
- public E removeFirst()`:移除并返回此列表的第一个元素。
- public E removeLast()`:移除并返回此列表的最后一个元素。
- public E pop()`:从此列表所表示的堆栈处弹出一个元素。
- public void push(E e)`:将元素推入此列表所表示的堆栈。
- public boolean isEmpty()`：如果列表不包含元素，则返回true。
public class LinkedListDemo2 {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("111");
linkedList.add("222");
linkedList.add("333");
linkedList.add("444");
// - public void addFirst(E e)`:将指定元素插入此列表的开头。
linkedList.addFirst("000");
System.out.println(linkedList); // [000, 111, 222, 333, 444]
// - public void addLast(E e)`:将指定元素添加到此列表的结尾。
linkedList.addLast("555");
System.out.println(linkedList); // [000, 111, 222, 333, 444, 555]
// - public E getFirst()`:返回此列表的第一个元素。
System.out.println(linkedList.getFirst()); // 000
// - public E getLast()`:返回此列表的最后一个元素。
System.out.println(linkedList.getLast()); // 555
// - public E removeFirst()`:移除并返回此列表的第一个元素。
linkedList.removeFirst();
System.out.println(linkedList); // [111, 222, 333, 444, 555]
// - public E removeLast()`:移除并返回此列表的最后一个元素。
linkedList.removeLast();
System.out.println(linkedList); // [111, 222, 333, 444]
// - public E pop()`:从此列表所表示的堆栈处弹出一个元素。
System.out.println(linkedList.pop()); // 111
// - public void push(E e)`:将元素推入此列表所表示的堆栈。
linkedList.push("push");
System.out.println(linkedList); // [push, 222, 333, 444]
// - public boolean isEmpty()`：如果列表不包含元素，则返回true。
System.out.println(linkedList.isEmpty()); // false
}
}
底层源码分析
Set 接口
特点
- Set不可重复
- 存储顺序不一致
- 没有带索引的方法,所有不能使用普通for循环,也不能通过索引来获取,删除Set集合里面的元素
public class SetDemo1 {
public static void main(String[] args) {
Set<String> set = new TreeSet<>();
set.add("ddd");
set.add("aaa");
set.add("aaa");
set.add("bbb");
set.add("ccc");
for (String s : set) {
System.out.println(s);
}
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
实现类
TreeSet
特点
- 不包含重复元素的集合
- 没有带索引的方法
- 可以将元素按照规则进行排序
- 想要使用TreeSet存储自定义对象,需要制定排序规则
public class TreeSetDem01 {
public static void main(String[] args) {
TreeSet<Integer> ts = new TreeSet<>();
ts.add(5);
ts.add(3);
ts.add(4);
ts.add(1);
ts.add(2);
System.out.println(ts); // [1, 2, 3, 4, 5]
}
}
自然排序Comparable的使用
- 使用空参构造创建TreeSet集合
- 自定义的Student类实现Comparable接口
- 重写里面的comparaTo方法
####### 原理
- 如果重写的方法返回值为负数,表示当前存入的元素是较小值,存左边
- 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
- 如果重写的方法返回值为正数,表示当前存入的元素是较大值,存右边
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student o) {
// 按照对象的年龄进行排序,年龄一样在按照姓名排序,
int result = this.age - o.age;
result = result == 0? this.name.compareTo(o.getName()) : result;
return result;
}
}
public class TreeSetDemo2 {
public static void main(String[] args) {
TreeSet<Student> treeSet = new TreeSet<>();
Student s1 = new Student("张三",18);
Student s2 = new Student("李四",22);
Student s3 = new Student("王五",20);
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
System.out.println(treeSet); // [Student{name='张三', age=18}, Student{name='王五', age=20}, Student{name='李四', age=22}]
}
}
比较器排序Comparable的使用
- TreeSet的带参构造方法使用的是比较器排序对元素进行排序的
- 比较器排序,就是让集合构造方法接收Cpmparator的实现类对象,重写compareTo(T o1,T o2)方法
-
重写方法的时候，一定要注意排序规则必须按照要求的主要条件和次要条件来写
public class TreeSetDemo4 {
public static void main(String[] args) {
TreeSet<Teacher> treeSet = new TreeSet<>(new Comparator<Teacher>() {
@Override
public int compare(Teacher o1, Teacher o2) {
// 主要条件
int result = o1.getAge() - o2.getAge();
// 次要条件
result = result == 0 ? o1.getName().compareTo(o2.getName()):result;
return result;
}
});
Teacher t1 = new Teacher("zhangsan",23);
Teacher t2 = new Teacher("lisi",23);
Teacher t3 = new Teacher("wangwu",40);
treeSet.add(t1);
treeSet.add(t2);
treeSet.add(t3);
System.out.println(treeSet);
}
}
public class Teacher {
private String name;
private int age;
public Teacher() {
}
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public Teacher(String name, int age) {
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;
}
}
注：在使用的时候,默认使用自然排序,当自然排序不满足现在的需求，使用比较器排序
HashSet
特点
- 底层数据结构是哈希表
- 不能保证存储和取出的顺序完全一致
- 没有带索引方法，所以不能使用普通for循环遍历
- 由于是Set集合，所以元素唯一
public class HashSetDemo1 {
public static void main(String[] args) {
HashSet<String> hs = new HashSet<>();
hs.add("Hello");
hs.add("World");
hs.add("Java");
hs.add("Java");
hs.add("Java");
hs.add("Html");
hs.add("CSS");
hs.add("JS");
Iterator<String> iterator = hs.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
for (String h : hs) {
System.out.println(h);
}
}
}
哈希值
哈希值(哈希码值)：是JDK根据对象的地址或者属性,算出来的int类型的整数
注：Object类中有一个方法可以获取对象的哈希值
public int hasCode():根据对象的地址值计算出来的哈希值
####### 特点
- 如果没有重写hasCode方法,那么是根据对象的地址址计算出的哈希值,同一个对象多次调用hasCode()方法返回的哈希值是相同的,不同对象的哈希值是不一样的。
- 如果重写了hasCode方法,一般都是通过对象的属性值计算出哈希值。如果不同的对象属性值是一样的,那么计算出来的的哈希值也是一样的。
####### Java底层实现
- JDK8之前,底层采用数组+链表实现。
- JDK8以后,底层进行了优化。由数组+链表+红黑树实现。
注：如果HashSet集合要存储自定义对象,那么必须重写hasCode和equals方法。
Map 接口
概述
Interface Map<K,V>: K表示值得数据类型,V表示值得数据类型- 键不能重复，值可以重复
- 键和值一一对应得,每一个值只能找到自己对应得值
- （键 + 值）这个整体我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象”
public class MapDemo1 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("001","张三");
map.put("002","李四");
map.put("003","王五");
System.out.println(map);
}
}
基本功能
V put(K key,V value)：添加元素
V remove(Objectkey)：根据键删除键值对元素
void clear()：移除所有的键值对元素
boolean containsKey(Object key)判断集合是否包含指定的键
boolean containsValue(Object value)判断集合是否包含指定的值
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中键值对的个数
Set<K> keySet() 获取所有键的集合
V get(Object Key) 根据键获取值
public class MapDemo2 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
// V put(K key,V value)：添加元素
map.put("001","小王");
map.put("002","小张");
map.put("003","小黄");
map.put("004","小刘");
System.out.println(map);
// V remove(Objectkey)：根据键删除键值对元素
map.remove("003");
System.out.println(map);
// boolean containsKey(Object key)判断集合是否包含指定的键
System.out.println(map.containsKey("001"));
System.out.println(map.containsKey("006"));
// boolean containsValue(Object value)判断集合是否包含指定的值
System.out.println(map.containsValue("小王"));
System.out.println(map.containsValue("小黄"));
// boolean isEmpty()判断集合是否为空
System.out.println(map.isEmpty());
// int size()集合的长度，也就是集合中键值对的个数
System.out.println(map.size());
// void clear()：移除所有的键值对元素
map.clear();
System.out.println(map);
}
}
public class MapDemo3 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("一号丈夫","一号妻子");
map.put("二号丈夫","二号妻子");
map.put("三号丈夫","三号妻子");
map.put("四号丈夫","四号妻子");
map.put("五号丈夫","五号妻子");
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(map.get(key));
}
}
}
遍历Map集合
- Set<Map.Entry<K,V> > entrySet() 获取所有键值对对象的集合
- K getKey() 获得键
-
V getValue() 获得值
public class MapDemo4 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("一号丈夫","一号妻子");
map.put("二号丈夫","二号妻子");
map.put("三号丈夫","三号妻子");
map.put("四号丈夫","四号妻子");
map.put("五号丈夫","五号妻子");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey() + "-" + entry.getValue());
}
}
}
实现类
HashMap
特点
- HashMap跟HashSet一样底层是哈希表结构的
- 依赖hashCode方法和equals方法保证键的唯一
- 如果键要存储的是自定义对象,需要重写hashCode的equals方法
package com.BJ.Map;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class MapDemo5 {
public static void main(String[] args) {
HashMap<Student,String> hm = new HashMap<>();
Student s1 = new Student("小河",20);
Student s2 = new Student("林格",22);
Student s3 = new Student("小刘",20);
hm.put(s1,"湖南");
hm.put(s2,"湖北");
hm.put(s3,"江苏");
Set<Student> students = hm.keySet();
for (Student student : students) {
System.out.println(hm.get(student));
}
Set<Map.Entry<Student, String>> entries = hm.entrySet();
for (Map.Entry<Student, String> entry : entries) {
System.out.println(entry.getKey() + "-----"+ entry.getValue());
}
hm.forEach((Student s,String str)->{
System.out.println(s+ "-----"+ str);
});
}
}
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}
#### TreeMap
- 底层是红黑树结构
- 依赖自然排序或者比较器排序,对**键**进行排序
- 如果键存储的是自定义对象,需要实现Comparable接口或者在吃鸡TreeMap的时候给出比较器排序规则
```Java
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
@Override
public int compareTo(Student o) {
int result = this.getAge() - o.getAge();
result = result == 0 ? this.getName().compareTo(o.getName()) : result;
return result;
}
}
public class MapDemo6 {
public static void main(String[] args) {
TreeMap<Student,String> tm = new TreeMap<>();
Student s1 = new Student("xiaohei",23);
Student s2 = new Student("xiaowang",25);
Student s3 = new Student("xiaoliu",25);
tm.put(s1,"江苏");
tm.put(s2,"湖南");
tm.put(s3,"四川");
tm.forEach((Student s,String str)->{
System.out.println(s+"----"+str);
});
}
}
拓展
增强for循环
只能遍历，不能增删,底层使用的也是迭代器。使用for循环的格式，简化了迭代器的书写
public interface Iterable<T>实现这个接口允许对象成为“foreach”语句的目标
格式：
for(元素的数据类型 变量;Collection集合or数组){
//写操作代码
}
泛型
概述
泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制,泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型， 泛型也可以看成是一个变量，用来接收数据类型
注意：泛型只能是引用类型，不能是基本类型。如果一个类后面有<E>，表示这个类是一个泛型类，创建泛型类的对象时,必须要给这个泛型确定具体的数据类型
泛型的好处
- 把运行时期的问题提前到了编译期
- 避免了强制类型转换
泛型的使用
泛型可以使用在:
- 类后面 ——> 泛型类
- 方法申明上 ——> 泛型方法
- 接口后面 ——> 泛型接口
泛型类的定义
格式
<类型>：指定一个类型的格式，尖括号里面可以任意书写，按照变量的定义规则即可，一般只写一个字母
修饰符 class 类名<类型>{}
public class Generic<T>{}:此处T可以随意写
```Java
public class GenericityClass {
public static void main(String[] args) {
Box<String> box = new Box<>();
box.setElement("字符串");
String element = box.getElement();
System.out.println(element);
Box<Integer> box2= new Box<>();
box2.setElement(19);
Integer element1 = box2.getElement();
System.out.println(element1);
}
}
public class Box<E> {
private E element;
public E getElement() {
return element;
}
public void setElement(E element) {
this.element = element;
}
}
泛型方法的定义
格式
格式：修饰符<类型> 返回值类型 方法名(类型 变量名){}
public<T> void show(T t){}
public class GenericityMethod {
public static void main(String[] args) {
ArrayList<String> list = addElement(new ArrayList<String>(), "a", "b", "c", "d");
System.out.println(list);
}
public static <T> ArrayList<T> addElement(ArrayList<T> list,T t1,T t2,T t3,T t4){
list.add(t1);
list.add(t2);
list.add(t3);
list.add(t4);
return list;
}
}
泛型接口的定义
泛型接口的使用方式
格式
格式：修饰符 interface 接口名<类型>{}
范例：public interface Generic<T>{}
public class GenericityInterface {
public static void main(String[] args) {
GenericityImpl<String> genericity = new GenericityImpl<>();
genericity.method("测试");
GenericityImpl1 genericityImpl1 = new GenericityImpl1();
genericityImpl1.method("类");
}
}
interface Genericity<E>{
public abstract void method(E e);
}
class GenericityImpl<E> implements Genericity<E>{
@Override
public void method(E e) {
System.out.println(e);
}
}
class GenericityImpl1<String> implements Genericity<String>{
@Override
public void method(String string) {
System.out.println(string);
}
}
泛型通配符
- 类型通配符
<?>
ArrayList<?>：表示元素类型未知的ArrayList,它的元素可以匹配任何的类型- 类型通配符上限：
<? extends 类型>
- 比如：
ArrayList<? extends Number>：它表示的类型是Number或者其他子类型
- 类型通配符下限：
<? super 类型>
- 比如：
ArrayList<? super Number>：它表示的类型是Number或其父类
public class Genericityglobbing {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
ArrayList<Number> list2 = new ArrayList<>();
ArrayList<Object> list3 = new ArrayList<>();
// printList(list1);
// printList(list2);
method1(list1);
method2(list2);
// method1(list3); // method1只能接收Number及其Number的子类
}
public static void method1(ArrayList<? extends Number> list){}
public static void method2(ArrayList<? super Number> list){}
private static void printList(ArrayList<?> list) {
System.out.println(list);
}
}
可变参数
public class VariableParameterDemo1 {
public static void main(String[] args) {
// 在JDK5之前,会把所有的数据都放到一个数组中
// 我们自定义的方法,形参只要写一个数组就可以了。
int[] arr = {1,2,3,4,5};
int sum1 = getSum(arr);
System.out.println(sum1);
}
private static int getSum(int[] arr) {
int result = 0;
for (int i : arr) {
result += i;
}
return result;
}
}
- 可变参数：就是形参的格式是可以发送编号的
- 格式：修饰符 返回值类型 方法名(数据类型... 方法名){}
- 范例：public static int sum(int...a){}
- 可变参数也是一个数组
- 如果一个方法有多个参数,包含可变参数,可变参数要放在最后
发表于 2021-7-16 23:03
|
发表于 2021-7-17 11:07
