回顾：
- Object
- getClass()
- hashCode()
- equals()
- toString()
- String
- String str = “hello world”; String str22 = “hello world”;
- String str2 = new String(“hello world”);
- str == str22 str.equals(str2)
- 常用方法
- charAt(int index); jackma
- length()
- indexOf()
- lastIndexOf()
- startsWith()
- endsWith()
- split()
- subString();
- Date
- Calendar
- get()
- set()
- add()
- getTime()
- BigDecimal
- 加减乘除
- SimpleDateFormat
- 对日期格式化 yyyy-MM-dd HH:mm:ss
- System
- arrayCopy()
- gc()
- exit(int flag)
集合
public interface Collection<E> {
int size();
boolean isEmpty();
void add(E e);
void remove(Object obj);
void clear();
}
1. List集合
list集合它是Collection的子接口
它有序可重复的
- 有序表示的是每个元素都有一个下标 下标从0开始，每次自增1
- 可以保存重复的数据
主要实现类：
- ArrayList
- LinkedList
- Vector
public interface List<E> extends Collection<E> {
//集合元素值，最大值Integer.MAX_VALUE
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
boolean add(E e);
boolean remove(Object o);
void clear();
//设置指定下标的元素值
E set(int index, E element);
//在执行位置添加元素
void add(int index, E element);
//查询该值的下标（第一次出现）
int indexOf(Object o);
//获取指定位置的元素
E get(int index);
}
package com.qf;
import java.util.ArrayList;
import java.util.List;
public class Demo01 {
public static void main(String[] args) {
/*
* 使用ArrayList实现类
*/
List<Integer> list = new ArrayList<Integer>();
/*
* 添加元素
* 从第一个添加的元素下标为0开始，每添加一个元素下标就自增1
* 一个集合元素的下标范围为[0 ~ size-1]
*/
list.add(1); //下标0
list.add(11); //下标1
list.add(2); //下标2
list.add(22); //下标...
//获取集合中添加的元素个数
int size = list.size();
System.out.println(size);
/*
* 通过下标，获取元素值
*/
int v1 = list.get(2);
System.out.println(v1);
/*
* 使用for循环遍历集合
* 既想获取值，又想获取下标
*/
for(int i=0; i<list.size(); i++) {
int v = list.get(i);
System.out.println(v);
}
System.out.println("-------------------");
/*
* 增强型for循环
* 如果只想获取集合中值
*/
for(int v : list) {
System.out.println(v);
}
/*
* 创建一个保存字符串的List集合
* 添加四个元素
* 使用两种方法，遍历集合
*/
}
}
package com.qf;
import java.util.LinkedList;
import java.util.List;
public class Demo02 {
public static void main(String[] args) {
/*
* LinkedList也是List的实现类
*/
List<Student> list = new LinkedList<Student>();
//添加元素
list.add(new Student("jackma", 17, "男"));
list.add(new Student("pony", 15, "男"));
list.add(new Student("小凌", 18, "女"));
//通过下标获取元素
Student s = list.get(1);
System.out.println(s);
/*
* for循环
*/
for(int i=0; i<list.size(); i++) {
Student stu = list.get(i);
System.out.println(stu);
}
System.out.println("-----------------------------");
for(Student student : list) {
System.out.println(student);
}
}
}
class Student {
private String name;
private Integer age;
private String gender;
public Student() {
}
public Student(String name, Integer age, String gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", gender=" + gender + "]";
}
}
package com.qf;
import java.util.List;
import java.util.Vector;
public class Demo03 {
public static void main(String[] args) {
/*
* 使用Vector实现类
*/
List<String> list = new Vector<String>();
list.add("jackma");
list.add("jordan");
list.add("james");
for(int i=0; i<list.size(); i++) {
String str = list.get(i);
System.out.println(str);
}
for(String str : list) {
System.out.println(str);
}
}
}
2. ArrayList
ArrayList是List的一种实现类，它的底层是一个数组
-
初始，数组为空数组
-
当添加第一个元素时，数组扩容到10
-
当添加2-10个元素时，数组都不会扩容
-
当添加第11个元素时，11>10 数组会扩容到15
-
当添加 12-15个元素时，数组不会扩容
-
当添加第16个元素，数组扩容为原来的1.5倍到22
-
。。。。。。
-
底层是数组
-
默认长度为10
-
扩容的时机：为原数组不够用的时候
-
每次扩容为原来的1.5倍
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
//默认数组长度
private static final int DEFAULT_CAPACITY = 10;
//空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//存放元素的数组 add添加数据，存储的位置
transient Object[] elementData;
//elementData数组中添加数据的个数 size()返回的值
private int size;
//ArrayList有参构造器，可以自定义初始容量
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
//无参构造器
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//添加元素方法
public boolean add(E e) {
//确认数组的长度是否够用，如果不够用，就扩容 size添加前数组中元素的个数
ensureCapacityInternal(size + 1);
//把添加的数据，放到elementData中
elementData[size++] = e;
return true;
}
//确认数组长度的方法
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//对确认容量参数的处理
private static int calculateCapacity(Object[] elementData, int minCapacity) {
/*
*判断当前保存元素的数组是否是空数组（是不是第一次添加）
如果第一次添加数组默认为空，那么默认长度为10
*/
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//判断容量需不需要自增
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
/*
*就是这个位置判断，底层的数组是否需要扩容，扩容的时机是什么
*
1. 第一次添加时，minCapacity=10， 数组会扩容10
2. 。。。
2.只有当当前数组中所有的位置添加满后，数组才会扩容 当添加第11个时扩容
*/
if (minCapacity - elementData.length > 0)
//扩容的方法
grow(minCapacity);
}
//扩容的方法
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length; //原容量
//新容量 = 原容量+原容量的一半 （数组扩容了1.5倍）
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 数组真正扩容的代码
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
4>>1
0000 0100 4
2>>1
0000 0010 2
0000 0001 1
106
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
