泛型
作用:将数据类型作为参数级进行传递\
优点:使代码更加灵活方便
语法
<泛型名1,泛型名2...>
注意:可以定义多个泛型,每个之间使用逗号隔开
泛型名称自定义,一般使用K,T,V,Y
泛型的定义与使用
定义位置
方法
语法: 访问访问权限修饰符 修饰词 <K,T..> 返回值类型 方法名(形参列表){
方法体
}
使用位置:1.返回值类型
2.形参列表
3.方法体中变量类型
类
语法 访问权限修饰符 class 类名<K,T...>{
}
继承关系中,父类有泛型
语法
访问权限修饰符 class 子类名<K,T...>extends 父类名 <父泛型>{
}
注意:子类中必须包含所有父泛型
使用
1.创建对象
传递有泛型类的对象时,必须传入泛型对应的数据类型
2.继承
可以在当前类任何一个使用数据类型的地方使用
例:
package com.qf.demo03;
/**
* 泛型在类上定义的使用1
* 创建对象
*/
public class Demo03 {
public static void main(String[] args) {
Person<String, Integer, Character> p1 =
new Person<String, Integer, Character>
("张三", 4, '男');
Person<Integer, Integer, String> p2 =
new Person<Integer, Integer, String>(11, 18, "女");
String name = p1.getName();
Integer name2 = p2.getName();
}
}
接口
:
语法
:
访问权限修饰符 interface
类名
<K,Y,...> {
}
实现关系中,
接口中有泛型
访问权限修饰符 class 子类名 <K,Y,...> implements
接口名
<
接口泛型
> {
}
注意
:
子类必须包含接口的所有泛型
继承关系中
,
接口中有泛型
访问权限修饰符 interface 子接口名 <K,Y,...> extends
接口名
<
接口泛型
> {
}
注意
:
子接口必须包含接口的所有泛型
使用
:
1,创建对象
传递有泛型的类的对象时,必须传入泛型对应的数据类型
2,继承
参考定义中继承的语法
可以在当前接口中任何一个使用数据类型的地方使用
例:
package com.qf.demo04;
public class Demo04 {
public static void main(String[] args) {
}
}
interface A<K>{
}
interface B<V>{
}
class Test<K,V> implements A<K>,B<V>{
}
interface C<K,V> extends A<K>,B<V>{
}
集合
作用:存储一组数据类型相同的数据
与数组的区别
数组:长度固定的,不可变的,可以存储基本数据类型和引用数据类型
集合:长度不固定,可以改变,只能存储引用数据类型
体系
Collection(
接口
)
---List(
子接口
)
------ArrayList(
子类
)
------LinkedList(
子类
)
------Vector(
子类
)
---Set(
子接口
)
------HashSet(
子类
)
------LinkedHashSet(
子类
)
------TreeSet(
子类
)
---Queue(
子接口
,
队列
)
作用与区别
Collection
作用:
存储数据
,
操作数据
特点:无序
(
存入顺序与取出顺序不一致
),
无下标
List
特点:
有序
(
存入顺序与取出顺序一致
),
有下标
,
数据可重复
ArrayList:
数据结构:数组
特点:
查询速度快
,
增删慢
线程不安全的
JDK1.2出现
LinkedList:
数据结构:
链表
特点:
增删快
,
查询速度慢
Vector(
了解
):
数据结构:
数组
特点:
查询速度快
,
增删慢
线程安全的
JDK1.0出现
Set
特点:
无序
,
有下标
,
数据不允许重复
注意:LinkedHashSet
有序
HashSet:
数据结构:
红黑树
(
二叉树
)+
哈希表
(
为了内部排序
)
特点:
有自己的排序规则
LinkedHashSet:
数据结构:
红黑树
(
二叉树
)+
链表
+
哈希表
(
为了内部排序
)
特点:Set
家族中唯一一个有序的
TreeSet:
数据结构:
红黑树
(
二叉树
)+
自己写排序规则
特点:
可以自定义排序规则
Collection提供的方法
增
:
boolean add(E e):一次添加一个数据
,
返回值表示是否添加成功
boolean addAll(Collection<? extends E> c):一次添加多个
例:
package com.qf.demo05;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class Demo05 {
public static void main(String[] args) {
ArrayList<String> list01 = new ArrayList<String>();
list01.add("10");
ArrayList<Integer> list02 = new ArrayList<Integer>();
}
}
删
:
boolean remove(Object o):一次删除一个
,
返回值表示是否删除成功
boolean removeAll(Collection<?> c):一次删除多个数据
void clear():清空
改
:
没有提供修改的方法
查
:
int size():获取集合长度,
返回值为该集合中元素的个数
boolean contains(Object o):判断参数中的元素是否在当前集合中存在
boolean isEmpty():判断集合中是否不存在元素
,
返回值为
true
表示当前集合为空集合
,
反之该结合有存储的元素
特殊的查询
:
遍历
方式1:
使用
foreach
方案2:
使用
Collection
实现的
Iterable
进行遍历
Iterable
提供的方法有
:
Iterator<T> iterator():获取迭代器
Iterator提供的方法有
:
boolean hasNext():判断下一个是否有值
E next():移动游标获取值
例:
package com.qf.demo07;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class TestCollection {
public static void main(String[] args) {
//Collection<Integer> col = new ArrayList<Integer>();
Collection<Integer> col = new HashSet<Integer>();
boolean b1 = col.add(10);
System.out.println(b1);
boolean b2 = col.add(10);
col.add(110);
System.out.println(b2);
System.out.println(col);
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(10);
boolean b3 = col.addAll(list);
System.out.println(col);
System.out.println(b3);
boolean b4 = col.remove(4);
System.out.println(col);
System.out.println(b4);
ArrayList<Integer> list2 = new ArrayList<Integer>();
// list2.add(1);
//list2.add(2);
list2.add(4);
boolean b5 = col.removeAll(list2);
System.out.println(col);
System.out.println(b5);
// col.clear();
System.out.println(col);
int size = col.size();
boolean b6 = col.contains(1);
System.out.println(b6);
boolean b7 = col.isEmpty();
System.out.println(b7);
System.out.println("--------foreach----------");
for(Integer n : col) {
System.out.println(n);
}
System.out.println("------使用迭代器-------");
//获取迭代器
Iterator<Integer> iterator = col.iterator();
//循环判断下一个是否有值
while(iterator.hasNext()) {
//有值,取值
Integer n = iterator.next();
System.out.println(n);
}
}
}
List提供的方法
1,
包含
Collection
提供的所有方法
增
:
void add(int index, E element):给指定位置添加数据
index:指定的位置
(
位置的索引
)
element:本次添加的数据
boolean addAll(int index, Collection<? extends E> c):给指定位置插入多个数据
index:指定的位置
(
位置的索引
)
c:本次添加的集合
删
:
E remove(int index):删除指定位置的数据
改
:
E set(int index, E element):修改
index:修改的元素的位置
element:修改后的元素
查
:
E get(int index):获取指定位置的元素
int indexOf(Object o):获取元素在集合中的位置
,
如果不存在返回
-1
int lastIndexOf(Object o):获取元素最后一次出现的位置
,
如果不存在返回
-1
其他
:
List<E> subList(int fromIndex, int toIndex):截取
fromIndex:开始位置
,
包含
toIndex:结束位置
,
不包含
返回值:
截取出元素的集合
例:
package com.qf.demo07;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
public class TestList {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(2);
System.out.println(list);
list.add(0, 10);
System.out.println(list);
HashSet<Integer> set = new HashSet<Integer>();
set.add(9);
set.add(8);
boolean b1 = list.addAll(1, set);
System.out.println(list);
System.out.println(b1);
System.out.println("---删除---");
Integer n = list.remove(0);
System.out.println(list);
System.out.println(n);
System.out.println("---截取---");
List<Integer> list2 = list.subList(2, list.size());
System.out.println(list2);
System.out.println(list);
System.out.println("---修改---");
list.set(0, -1);
System.out.println(list);
System.out.println("---查询---");
Integer x = list.get(0);
System.out.println(x);
System.out.println("查询指定元素所在的位置");
int index = list.indexOf(4);
System.out.println(index);
int lastIndexOf = list.lastIndexOf(10);
System.out.println(list);
System.out.println(lastIndexOf);
}
}
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
