Java暑期学习Day36
本帖最后由 马太效应 于 2017-8-11 22:02 编辑今天是第36天，鼠标终于可以正常使用了{:10_298:}
static/image/hrline/5.gif
① ArrayList
构造方法
ArrayList()
构造一个初始容量为十的空列表。
ArrayList(Collection<? extends E> c) 构造一个包含指定集合的元素的列表，
按照它们由集合的迭代器返回的顺序。
ArrayList(int initialCapacity)
构造具有指定初始容量的空列表。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ArrayListDemo {
public static void main(String[] args) {
/*
* 当我们调用无参数构造方法来构造一个ArrayList对象的时候
* 它会在内部分配一个初始大小为10的一个Object类型的数组
*
* 当添加的数据容量超过数组大小的时候，会产生一个新的数组，
* 新的数组大小为原来数组大小的1.5倍，接着把原数组中的数据
* 拷贝到新的数组中
*
*
*/
List<String> nList=new ArrayList<String>();
nList.add("panda");
nList.add("apple");
nList.add("banana");
nList.add("peal");
nList.add(1,"fish");
nList.set(0, "Apanda");
System.out.println("使用迭代器对象来进行统一的遍历");
Iterator<String> it=nList.iterator();
while(it.hasNext()){
String name=it.next();
System.out.println(name);
}
System.out.println("使用增持for循环进行遍历");
for(String name1:nList){
System.out.println(name1);
}
System.out.println("********************");
System.out.println(nList.indexOf("peal"));
System.out.println(nList.remove("Apanda"));
System.out.println(nList.remove(0));
System.out.println(nList.size());
System.out.println(nList.contains("Apanda"));
System.out.println(nList.get(0));
System.out.println(nList.isEmpty());
nList.clear();
System.out.println(nList.isEmpty());
}
}
结果是——
使用迭代器对象来进行统一的遍历
Apanda
fish
apple
banana
peal
使用增持for循环进行遍历
Apanda
fish
apple
banana
peal
********************
4
true
fish
3
false
apple
false
true
1.数组在内存中是连续的线性空间，根据索引随机存取的速度快，如排序时使用。
2.在ArrayList内部数组长度不够时，会建立新数组，并将旧的数组的参考指定给新的数组。
import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo2 {
public static void main(String[] args) {
List<Student> stuList=new ArrayList<Student>();
Student stu1= new Student("zs",10);
Student stu2= new Student("ls",20);
Student stu3= new Student("jk",30);
Student stu4= new Student("my",10);
Student stu5= new Student("ry",20);
stuList.add(stu1);
stuList.add(stu2);
stuList.add(stu3);
stuList.add(stu4);
stuList.add(stu5);
Student stu6=new Student("my",10);
System.out.println(stuList.indexOf(stu6));
System.out.println(stuList.contains(stu6));
System.out.println(stuList.remove(stu6));
System.out.println(stuList.indexOf(stu4));
System.out.println(stuList.size());
}
}
class Student{
private String name;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
private int 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 boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}结果是——
3
true
true
-1
4
3.语法细节
ArrayList 的父类是 AbstractList。
AbstractList的唯一构造方法的详细信息：
protected AbstractList()唯一的构造函数。
（用于子类构造函数的调用，通常是隐式的。）
-！-
public String toString()
返回对象的字符串表示形式。 一般来说， toString方法返回一个“textually代表”这个对象的字符串。 结果应该是一个简明扼要的表达，容易让人阅读。 建议所有子类覆盖此方法。
该toString类方法Object返回一个由其中的对象是一个实例，该符号字符`的类的名称的字符串@ ”和对象的哈希码的无符号的十六进制表示。 换句话说，这个方法返回一个等于下列值的字符串：
getClass().getName() + '@' + Integer.toHexString(hashCode())
结果——对象的字符串表示形式
② LinkedList--链表
All implemented Interfaces:
Serializable
(可串行化的)
Cloneable（可复制的）
Iterable<E>
（可迭代的）
Collection<E>
（集合）
Deque<E>
（双端队列）
List<E>
(序列)
Queue <E>
（队列）
构造方法
LinkedList() 构造一个空列表。
LinkedList(Collection<? extends E> c) 构造一个包含指定集合的元素的列表，
按照它们由集合的迭代器返回的顺序。
1.LinkedList类扩展AbstractSequentialList(其父类)并实现List和Deque接口<JDK8.0视角>。
2.LinkedList提供了一个链表数据结构。
3.除了继承的方法之外，LinkedList类还定义了一些有用的方法用于操作和访问容器中的数据。
4.LinkedList在操作List接口时，采用了链接结构，不会事先耗费内存，想要指定索引随机存取对象时，会比较没有效率，链接的每个元素会参考下一个元素，这有利于调整索引顺序。
import java.util.Iterator;
import java.util.LinkedList;
public class LinkedListDemo1 {
/*
* LinkedList它内部封装的是双向链表
* 数据结构每个节点是一个Node对象，Node对象中封装的是你要添加的元素
* 还有一个指向上一个Node对象的引用和指向下一个Node对象的引用
*
* 不同的容器有不同的数据结构，不同的数据结果操作起来性能 是不一样的
*
* 链接数据结构，做插入、删除的效率比较高，但查询效率较低
*
* 数组结构，它做查询的时候效率高，因为可以通过下表直接找到元素 但插入和删除效率比较低，因为要做移位操作
*/
public static void main(String[] args) {
LinkedList<String> sList = new LinkedList<String>();
sList.add("zs");
sList.add("ls");
sList.add("wu");
sList.add("rs");
sList.add("my");
sList.add("jk");
sList.addFirst("panda");
sList.addLast("mandy");
Iterator<String> it = sList.iterator();
while (it.hasNext()) {
String name = it.next();
System.out.println(name);
}
System.out.println("*****************************************");
for (Iterator<String> it2 = sList.iterator(); it2.hasNext();) {
String name = it2.next();
System.out.println(name);
}
System.out.println("*****************************************");
for (String name : sList) {
System.out.println(name);
}
System.out.println(sList.removeFirst());
System.out.println(sList.size());
sList.clear();
System.out.println(sList.pollFirst());
System.out.println(sList.size());
}
}
结果是——
panda
zs
ls
wu
rs
my
jk
mandy
*****************************************
panda
zs
ls
wu
rs
my
jk
mandy
*****************************************
panda
zs
ls
wu
rs
my
jk
mandy
panda
7
null
0
页:
[1]