JAVA语言编程（六）：包装类、Collection集合、Iterator接口、泛型、List集合、Set接口、可变参数
JAVA语言编程（六）：包装类、Collection集合、Iterator接口、泛型、List集合、Set接口、可变参数
- 1. 包装类：
-
- 1.1 装箱与拆箱：
- 1.2 自动装箱和自动拆箱：
- 1.3 基本数据类型与字符串的转换：
- 2. Collection集合：
-
- 2.1 集合框架：Collection包含：
- 2.2 Collection常用方法：
- 3. Iterator接口：
-
- 3.1 Iterator基本方法：
- 3.2 增强for循环：
- 4. 泛型：
-
- 4.1 使用泛型的好处：
- 4.2 含有泛型的类：
- 4.3 含有泛型的方法：
- 4.4 含有泛型的接口：
-
- 4.4.1 方式1：
- 4.4.2 方式2：
- 4.5 泛型的通配符：
- 4.6 通配符高级使用——受限泛型：
- 5. List集合：
-
- 5.1 ArrayList集合：
- 5.2 LinkedList集合：
- 5.3 Vector集合：
- 6. Set接口：
-
- 6.1 HashSet集合：
- 6.2 HashSet底层结构：
- 6.3 Set不允许重复元素的原理：
- 6.4 HashSet存储自定义类型元素：
- 6.5 LinkedHashSet集合：
- 7. 可变参数：
1. 包装类：
使用一个类把基本数据类型包装起来，这个类称为包装类。这个类中可以定义一些方法，用于操作基本数据类型。
1.1 装箱与拆箱：
package lch;
public class fangfa {
public static void main(String[] args){
//构造方法：
Integer i1 = new Integer(5);
int n1 = i1.intValue();
//静态方法：
Integer i2 = Integer.valueOf(3);
}
}
1.2 自动装箱和自动拆箱：
package lch;
import java.util.ArrayList;
public class fangfa {
public static void main(String[] args){
//自动装箱：
Integer i1 = 5;
//自动拆箱：
int n1 = i1 + 4;
System.out.println(n1);
ArrayList<Integer> list1 = new ArrayList<>();
//自动装箱：
list1.add(1);
list1.add(2);
}
}
1.3 基本数据类型与字符串的转换：
package lch;
public class fangfa {
public static void main(String[] args){
//基本数据类型转字符串：
int n1 = 4;
String str1 = n1 + "";
String str2 = Integer.toString(n1);
String str3 = String.valueOf(n1);
//字符串转基本数据类型：
String str4 = "1234";
int n2 = Integer.parseInt(str4);
}
}
2. Collection集合：
集合是Java提供的一种容器，可以存储多个元素。
集合的长度是可以变化的。
集合存储的都是对象，且对象的类型可以不一致。
2.1 集合框架：Collection包含：
List接口：Vector集合，ArrayList集合，Linkedlist集合。
有序，允许重复，有索引。
Set接口：TreeSet集合，HashSet集合，LinkedHashSet集合。
不允许重复，无索引。
2.2 Collection常用方法：
package lch;
import java.util.ArrayList;
import java.util.Collection;
public class fangfa {
public static void main(String[] args){
Collection<String> c1 = new ArrayList<>();
System.out.println(c1);
c1.add("abc");
c1.clear();
c1.add("abc");
c1.remove("abd");
System.out.println(c1.contains("abc"));
System.out.println(c1.isEmpty());
System.out.println(c1.size());
c1.add("abc");
c1.add("abc");
String[] str = new String[6];
c1.toArray(str);
System.out.println(str[0]);
}
}
3. Iterator接口：
迭代是Collection集合元素的通用获取方式。
3.1 Iterator基本方法：
Iterator是一个接口，不能直接使用。需要使用Collection中的iterator方法。
.next()方法自带步进效果。
package lch;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class fangfa {
public static void main(String[] args){
Collection<String> c1 = new ArrayList<>();
c1.add("aaa");
c1.add("bbb");
c1.add("ccc");
Iterator<String> it1 = c1.iterator();
while(it1.hasNext()){
System.out.println(it1.next());
}
}
}
3.2 增强for循环：
JDK1.5之后的新特性。
所有的单列集合都可以使用增强for循环。
package lch;
import java.util.ArrayList;
import java.util.Collection;
public class fangfa {
public static void main(String[] args){
int[] a = {
1,2,3,4,5};
for(int i : a){
System.out.println(i);
}
Collection<String> c1 = new ArrayList<>();
c1.add("aaa");
c1.add("bbb");
c1.add("ccc");
for(String it : c1){
System.out.println(it);
}
}
}
4. 泛型：
4.1 使用泛型的好处：
创建集合，不使用泛型：
好处：集合不使用泛型，默认的类型就是Object类，可以存储任意类型的数据。
坏处：不安全，会引发异常。
package lch;
import java.util.ArrayList;
import java.util.Iterator;
public class fangfa {
public static void main(String[] args){
ArrayList list = new ArrayList();
list.add(1);
list.add("abc");
Iterator it= list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
这样写就不能使用String特有的方法。
创建集合，使用泛型：
好处：避免了类型转换的麻烦。把运行期异常提前到了编译期。
坏处：泛型是什么类型就只能存储什么类型。
4.2 含有泛型的类：
package lch;
public class Person<E> {
public E name;
}
package lch;
public class fangfa {
public static void main(String[] args){
Person<Integer> p1 = new Person<>();
p1.name = 12321;
System.out.println(p1.name);
}
}
4.3 含有泛型的方法：
package lch;
public class Person {
public <E> E method1(E a){
return a;
}
}
package lch;
public class fangfa {
public static void main(String[] args){
Person p1 = new Person();
System.out.println(p1.method1(5));
System.out.println(p1.method1("qdqwed"));
}
}
4.4 含有泛型的接口：
4.4.1 方式1：
package lch;
public interface MyInterfaceAbstract<I> {
abstract void method(I i);
}
package lch;
public class MyInterfaceImpl implements MyInterfaceAbstract<String>{
@Override
public void method(String str1) {
System.out.println(str1);
}
}
4.4.2 方式2：
package lch;
public interface MyInterfaceAbstract<I> {
abstract void method(I i);
}
package lch;
public class MyInterfaceImpl<I> implements MyInterfaceAbstract<I>{
@Override
public void method(I i) {
System.out.println(i);
}
}
4.5 泛型的通配符：
当不知道使用什么类型时，可以使用?来表示未知通配符。只能使用Object类中的共性方法，集合中元素自身方法无法使用。
不能创建对象使用，只能作为方法的参数使用。
package lch;
import java.util.ArrayList;
import java.util.Iterator;
public class fangfa {
public static void main(String[] args){
ArrayList<Integer> a1 = new ArrayList<>();
a1.add(1);
a1.add(2);
a1.add(3);
ArrayList<String> a2 = new ArrayList<>();
a2.add("a");
a2.add("b");
a2.add("c");
printlist(a1);
printlist(a2);
}
public static void printlist(ArrayList<?> list){
Iterator<?> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
4.6 通配符高级使用——受限泛型：
泛型的上限：? extneds E代表使用的泛型必须是E类型的子类或本身
泛型的下限：? super E代表使用的泛型必须是E类型的父类或本身
5. List集合：
List三大特点：
1.有序；
2.有索引；
3.允许重复元素。
5.1 ArrayList集合：
底层是数组结构。多线程实现。
增删的底层原理是把元素复制到一个新的数组中去。
5.2 LinkedList集合：
底层是链表结构。
package lch;
import java.util.Iterator;
import java.util.LinkedList;
public class fangfa {
public static void main(String[] args){
LinkedList<Integer> list1 = new LinkedList<>();
list1.add(3);
list1.add(4);
list1.add(5);
list1.addFirst(2);
list1.addLast(6);
list1.remove(2);
Iterator it = list1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
5.3 Vector集合：
底层结构也是数组，但是是单线程的，速度较慢。
6. Set接口：
不允许重复元素，无索引。
6.1 HashSet集合：
底层是一个哈希表，查询快。
package lch;
import java.util.HashSet;
import java.util.Iterator;
public class fangfa {
public static void main(String[] args){
HashSet<Integer> set1 = new HashSet<>();
set1.add(4);
set1.add(2);
set1.add(3);
Iterator it = set1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
for(Integer i:set1){
System.out.println(i);
}
}
}
在Object类有一个int hashCode()方法，可以获取对象的哈希值，等于地址的10进制值。
package lch;
public class fangfa {
public static void main(String[] args){
Person p1 = new Person();
System.out.println(p1.hashCode());
Animal a1 = new Animal();
System.out.println(a1.hashCode());
}
}
6.2 HashSet底层结构：
JDK1.8之前：数组+链表
JDK1.8之后：数组+链表，超过8位的链表会转化为红黑树
6.3 Set不允许重复元素的原理：
Set在使用add方法时会调用hashCode()方法和equals()方法，来判断是否重复。
6.4 HashSet存储自定义类型元素：
必须重写hashCode和equals方法，否则不能去重。
package lch;
import java.util.Objects;
public class Animal {
Animal(){
}
Animal(String name, int age){
this.age = age;
this.name = name;
}
private String name;
private int age;
@Override
public String toString() {
return "Animal{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Animal animal = (Animal) o;
return age == animal.age &&
Objects.equals(name, animal.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
package lch;
import java.util.HashSet;
import java.util.Iterator;
public class fangfa {
public static void main(String[] args){
Animal a1 = new Animal("a", 1);
Animal a2 = new Animal("a", 1);
Animal a3 = new Animal("b", 1);
Animal a4 = new Animal("a", 2);
HashSet<Animal> set1 = new HashSet<>();
set1.add(a1);
set1.add(a2);
set1.add(a3);
set1.add(a4);
Iterator it = set1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
6.5 LinkedHashSet集合：
继承了HashSet集合。底层是哈希表+链表。链表用来记录元素存储顺序，保证元素有序。
package lch;
import java.util.*;
public class fangfa {
public static void main(String[] args){
HashSet<Integer> s1 = new HashSet<>();
LinkedHashSet<Integer> s2 = new LinkedHashSet<>();
s1.add(1);
s1.add(3);
s1.add(2);
s2.add(1);
s2.add(3);
s2.add(2);
Iterator it1 = s1.iterator();
Iterator it2 = s2.iterator();
while(it1.hasNext()){
System.out.println(it1.next());
}
System.out.println();
while(it2.hasNext()){
System.out.println(it2.next());
}
}
}
7. 可变参数：
参数列表数据类型确定但个数不确定时可以使用。
可变参数底层是一个数组，传递参数个数可以是0个，1个或多个。
一个方法的参数列表只能有一个可变参数，且必须写在参数列表末尾。
格式：修饰符 返回值类型 方法名(参数类型...形参名){}
package lch;
public class fangfa {
public static void main(String[] args){
int[] a = {
1,3,5,3,5,3,2,3,6};
System.out.println(method1(a));
System.out.println(method2(a));
}
public static int method1(int...a){
int sum = 0;
for(int i:a) {
sum += i;
}
return sum;
}
public static int method2(int a[]){
int sum = 0;
for(int i:a) {
sum += i;
}
return sum;
}
}