总结
泛型
● 参数化类型，就是将类型由原来的具体的类型参数化。
package javaCollection;
import java.util.Date;
public class FanXing {
/*
泛型：参数化类型
类型参数化
type
*/
public class Demo<T,E>{
T name;
E age;
public T eat(T age){
System.out.println(age);
return null;
}
public void main(String[] args) {
Demo<String,Integer> demo=new Demo();
demo.age=100;
}
}
/*
public static void main(String[] args) {
//虽然可以使用Object表示任何的数据类型
// 但实际操作时我们需要向下转型。带来不方便，不安全的隐患
java.lang.Object[] objs={"a",new Date(),1,true};
for(java.lang.Object obj:objs){
//instanceof 左边对象是否为instanceof 右边类的实例
if(obj instanceof String) {
String s = (String) obj; //obj对象强制转换为String
System.out.println(s.length());
}
}
}*/
}
集合
概述： 集合/容器 类似于 数组 存储一组数据 空间连续 长度是固定的
java中为什么提供许多的集合类?
- 1.数组长度不可变 实际中的数量是变化的.
- 2.数据存储特征也不同 数据结构不同, 有的查询多,数组首选, 有的增删多 链表
集合框架是由很多接口、抽象类、具体类组成的，都位于java.util包中
集合体系：
Collection接口
定义了存取一组对象的方法，其子接口Set和List分别定义 了存储方式
● Set 中的数据对象没有顺序且不可以重复。
● List 中的数据对象有顺序且可以重复。
package javaCollection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo1 {
public static void main(String[] args) {
/*
Collection定义常用方法
集合中只能存储引用类型
int[] a={11,1}
String[] string={};
*/
//建议使用泛型明确数据类型
Collection<Integer> c=new ArrayList();
int a=10;
c.add(10);
c.add(11);
c.add(a); //添加时会自动装箱
//c.clear();
//System.out.println(c.isEmpty()); //true 判断是否为空 为空-true 否则false
System.out.println(c); //[]
System.out.println(c.contains(11)); //[10, 11, 10]
c.remove(11);
System.out.println(c.size()); //2
System.out.println(c); //[10, 10]
}
}
package javaCollection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo2 {
public static void main(String[] args) {
Collection<Integer> c=new ArrayList<>();
c.add(1);
c.add(2);
c.add(3);
c.add(4);
System.out.println(c); //[1, 2, 3, 4]
Collection<Integer> c1=new ArrayList<>();
c1.add(4);
c1.add(5);
c1.add(6);
c1.add(7);
c.addAll(c1); //将c1集合元素添加到c中
System.out.println(c.containsAll(c1)); //c里是否包含c元素 true
System.out.println(c.removeAll(c1)); //删除指定集合中包含所有集合的元素
System.out.println(c.retainAll(c1)); //保留两个集合中相同内容 c里移出c1 true
System.out.println(c); //[1, 2, 3, 4, 4, 5, 6, 7] [1, 2, 3]
System.out.println(c1); //[4, 5, 6, 7]
}
}
package javaCollection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo3 {
public static void main(String[] args) {
Collection<Integer> c=new ArrayList<>();
c.add(1);
c.add(2);
c.add(3);
c.add(4);
//集合转数组
/*Object[] objects=c.toArray();
System.out.println(objects.length);*/
Integer[] array=c.toArray(new Integer[c.size()]);
}
}
List
List接口 继承Collection
有序的(按照插入元素的顺序排列),存储重复元素,值插入后会有索引,可以通过索引访问元素
ArrayList
底层是数组,查询块,从中间增删慢
LinkList
底层是双向链表,查询慢,从中间增删快
Vector
底层是数组,查询快,从中间增删慢,线程安全
ArrayList
实现了长度可变的数组，在内存中分配连续的空间。
ArrayList<String> list=new ArrayList<>();
匿名内部类 可以自己定义类，复制方法，接口实现
ArrayList1:
package javaCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.Predicate;
public class ArrayList1 {
public static void main(String[] args) {
/*
ArrayList(); 默认不创建底层数组，当添加第一个元素时，创建一个长度为10的数组
ArrayList(int length); 创建对象时,创建一个指定长度的数组
ArrayList(Collection collection); 把一个实现了Collection接口的子类，构造成一个Arraylist
add(E e)向列表末尾添加元素
add(int index,E e)向指定位置添加元素
add方法add方法底层数组扩容 当底层数组装满之后,会自动扩容为原来的1.5倍
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 检测是否还有位置
elementData[size++] = e;
return true;
}
if (minCapacity - elementData.length > 0)//判断是否可以放得下
grow(minCapacity);扩容方法
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容1.5
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) //判断数组索引是否大于Int的最大值
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
* 原数组 新长度
elementData = Arrays.copyOf(elementData, newCapacity);//进行数组赋值
返回一个新数组
*/
ArrayList<String> list=new ArrayList<>();
list.add("a"); //0="a" size=1
list.add("b");
list.add("c");
list.add(0,"x");
list.add("d");
list.add("e"); //0="a" 1="b" 2="c" 3="d" 4="e" size=5
//[a,b,c,d,e,null,null,null,null,null]
list.add("e");
list.add("e");
list.add("e");
list.add("e");
list.add("e");
list.add("e");
/*
E elementData(int index){
return(E) elementData[index]
}
*/
//System.out.println(list.get(2)); //查询快 直接返回指定位置的值 b
//System.out.println(list.remove(3)); //删除指定位置元素 c
System.out.println(list); //删除c之后输出的list [x, a, b, d, e, e, e, e, e, e, e]
/*//条件删除
list.removeIf(new Predicate<String>() { //new一个匿名内部类
@Override
public boolean test(String t) {
return t.equals("e"); //条件满足删除元素
}
});*/
list.set(0,"w"); //替换指定位置的值 [w, a, b, c, d, e, e, e, e, e, e, e]
System.out.println(list); //[x, a, b, d]
}
}
FilterDemo:
package javaCollection;
import java.util.function.Predicate;
public class FilterDemo implements Predicate<String>{
@Override
public boolean test(String s) {
return false;
}
}
ArrayList2:
package javaCollection;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
public class ArrayList2 {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>(7);
list.add("a");
list.add("b");
list.add("a");
list.add("c");
list.add("d");
list.add("e");
/*
list.sort(new Comparator<String>() { //排序 指定排序的规则
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
System.out.println(list); //[a, a, b, c, d, e]
*/
//匿名内部类可以自己定义类，复制方法，接口实现
//list.sort(new StringSort());
List<String> li=list.subList(0,4); //从原集合中复制一段返回新集合
System.out.println(list); //[a, a, b, c, d, e]
}
}
StringSort:
package javaCollection;
import java.util.Comparator;
public class StringSort implements Comparator<String> {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
}
LinkList
底层双向链表
- 传入一个索引,如果索引小于集合的一半,从头结点开始查找,知道找到这个位置的值
如果大于一半，从尾结点开始查找,直到找到这个位置的值
LinkedList<String> list=new LinkedList<>();
package javaCollection;
import java.util.LinkedList;
public class LinkedList1 {
public static void main(String[] args) {
LinkedList<String> list=new LinkedList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//list.remove(2); //[a, b, d] 移除第三个
System.out.println(list.get(2)); //c
System.out.println(list); //[a, b, c, d]
/* Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
传入一个索引,如果索引小于集合的一半,从头结点开始查找,知道找到这个位置的值
如果大于一半，从尾结点开始查找,直到找到这个位置的值
*/
}
}
Vector
底层是数组 线程安全
public synchronized(同步锁) boolean add(E e)
Vector<String> v=new Vector<>();
package javaCollection;
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
Vector<String> v=new Vector<>();
v.add("a");
v.add("a");
v.add("b");
v.add("a");
v.add("a");
System.out.println(v); //[a, a, b, a, a]
}
/*
底层也是数组 查询快,中间增删慢,是线程安全的
public synchronized(同步锁) boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
*/
}
list迭代
遍历：
- 方式1: for循环遍历
length(数组) length()(字符串) size()(集合)
循环时允许删除元素,但是我们需要注意索引与集合长度之间的关系 - 方式2：增强for循环
循环时不允许删除元素 - 方式3：迭代器遍历
listIterator();只能用于list接口的集合
ListIterator<Integer>lit=list.listIterator(); - 方式4：Stream流遍历
Stream s=list.stream();
package javaCollection;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDiedai1 {
public static void main(String[] args) {
ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(1);
/* 遍历
方式1: for循环 length(数组) length()(字符串) size()(集合)
循环时允许删除元素,但是我们需要注意索引与集合长度之间的关系
for(int i=0;i<list.size();i++){
if(list.get(i)==1){
list.remove(i);
i--;
}
//System.out.println(list.get(i)); //1 2 3 4 5 1
}
System.out.println(list); //[2, 3, 4, 5]
*/
/*
方式2：增强for循环
循环时不允许删除元素
for(Integer item:list){
if(item==1){
list.remove(item);
}
System.out.println(item); //1 2 3 4 5 1
}
*/
/*
方式3：迭代器遍历
*/
Iterator<Integer> it= list.iterator();
while (it.hasNext()){
//System.out.println(it.next()); //1 2 3 4 5 1
Integer item=it.next();
if(item==1){
it.remove();
}
}
System.out.println(list); //[2, 3, 4, 5]
}
}
package javaCollection;
import java.util.ArrayList;
import java.util.ListIterator;
import java.util.stream.Stream;
public class ArrayListDiedai2 {
public static void main(String[] args) {
ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(1);
/*
方式3：迭代器遍历
listIterator();只能用于list接口的集合
*/
/*
ListIterator<Integer> lit=list.listIterator();
while (lit.hasNext()){
lit.next();
//lit.add(2); //[1, 2, 2, 2, 3, 2, 4, 2, 5, 2, 1, 2]
lit.remove(); //[]
//System.out.println(lit.next()); //1 2 3 4 5 1/
}
System.out.println(list); */
//从指定位置开始 从后向前遍历 list.size()
ListIterator<Integer> lit=list.listIterator(list.size());
while (lit.hasPrevious()){
System.out.println(lit.previous()); //1 5 4 3 2 1
}
/*
Stream<Integer> s=list.stream();
s.forEach(t-> System.out.println(t)); //1 2 3 4 5 1
*/
}
}
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
