@2020-02-08
容器和数据结构**
##概念
- Collection表示一组对象，它是集中，收集的意思，就是把一些数据收集起来。
- Collection函数库是在java.util包下的一些类和接口，类拾用来产生对象存放数据用的，而接口是访问数据的方式。
- Collection 函数库与数组的两点不同：1）数组的容量是有限制的，而Collection是没有这样的限制。它容量可以自动调节。2) Collection函数库只能用来存放对象，而数组没有这样的限制
- Collection 接口是Collection层次结构中的接线口，它定义了一些最基础的访问方法，让我们能用同一的方式通过它或它的子接口来访问数据。
- 区别：Collection 代表一组对象，Collection 函数库就是java
- 框架：Collection接口，是这个集合框架中的根接口
- 存放在Collection库中的
API
Collection---Set--MashSet:不允许重复没有顺序 Collection--List 允许重复并且有序 Map--HashMap 键值对
泛型是JDK1.5后增加的
- ArrayList底层是用数组实现的存储。特点 ： 查询效率高，曾删效率低，线程不安全。我们一般使用它
- ? 数组长度是有限的，而ArrayList是可以存放任意数量的对象，长度不受限制，那么它拾怎么实现的呢？
LinkeList的特点和底层实现
- LinkeList 底层使用双向链表实现的存储。特点：查询效率低，曾删效率高，线程不安全。
- 双向链表页脚双链表，拾链表的一种，它的每个节点都有两个指针,分别指向前一个节点和后一个节点。所以，从双向链表的任意一个节点开始，都可以很方便的找到所有节点
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zNMjuP08-1581178973145)(https://www.sxt.cn/360shop/Public/admin/UEditor/20170524/1495616843888130.png (双向指针)])
class Node{
Node previous; //前一个节点
Object element //本节点保存的数据
Node next;
}
Vector向量
- Vector 底层是用数组实现的List，相关方法都加了同步检查，因此***线程安全，效率低*** 比如，indexOf方法就增加了synchronized同步标记
public synchronized int indexOf(Object o,int index){
//代码省略
}
小结：
- 如何选用ArrayList LinkeList Vector?
- 需要线程安全时，用Vetor
- 不存在线程安全问题时，并且查找较多用ArrayList（一般使用它）
- 不存在线程安全问题时， 增加和刪除元素較多時用LinkeList
附代码
*** LinkeList***
package mycollection;
/**
* 自定义链表
* 增加小的封装，泛型
* author 管浩杰
*/
public class SxtLinkeList05<E> {
private Node first;
private Node last;
private int size;
Object element;
//[]
public void add(E e){
//新的节点
Node node = new Node(e);
//链表为空
if(first == null){
// node.previous = null;
// node.next = null;
first = node;
last = node;
}else{
//链表不为空
node.previous = last; //新节点前一个为链表元素的最后一个
node.next = null; //新节点的下一个为空
last.next =node; //最后一个节点指向新节点
last = node;
}
size++;
}
public void add(int index,E e){
checkIndex(index);
Node newNode = new Node(e); // 创建新的节点
Node temp = getNode(index); //当前节点
if(temp!=null){
Node up =temp.previous;
up.next = newNode;
temp.previous = newNode;
newNode.previous= up;
newNode.next= temp;
}
}
// public void remove(){
//
// }
public void remove(int index){
checkIndex(index);
Node temp = getNode(index);
if(temp!=null){
Node up = temp.previous;
Node down = temp.next;
if(up!=null){
up.next = down;
}
if(down!=null){
down.previous = up;
}
if(index==0){
first = down;
}
if(index==size-1){
first = up;
}
size--;
}
}
public void remove(E e){
}
private void checkIndex(int index){
if(index<0||index>size-1){
throw new RuntimeException("索引数字不合法"+ index);
}
}
public Object get(int index){
checkIndex(index);
Node temp = getNode(index);
return temp!=null?temp.element:null;
}
private Node getNode(int index){
checkIndex(index);
Node temp = null;
if(index <= size>>1){//size>>1向右移动一位就是除以2
temp =first;
for(int i =0;i<index;i++){
temp = temp.next;
}
}else{
temp =last;
for(int i =size-1;i>index; i--){
temp = temp.previous;
}
}
return temp;
}
/*重写toString() 方法*/
@Override
public String toString(){
//[a,b,c] first=a last=c
//a,b.c
StringBuilder stb =new StringBuilder();
Node temp = first;
stb.append("[");
while(temp !=null){
stb.append(temp.element).append(",");
temp = temp.next;
}
stb.setCharAt(stb.length()-1,']');
return stb.toString();
}
public static void main(String[] args) {
SxtLinkeList05<String> list = new SxtLinkeList05<String>();
list.add("a");
list.add("a");
list.add("a");
list.add(2,"p");
System.out.println(list);
list.remove(0);
System.out.println(list);
System.out.println(list.get(1));
}
}
ArrayList
package mycollection;
import java.util.ArrayList;
/**
* 增加remove
* author 管浩杰
*/
public class SxtArrayList03<E> {
private Object[] elementData;
private int size;
private static final int DEFALT_CAPACITY = 10;
public SxtArrayList03(){
this(DEFALT_CAPACITY);
}
public SxtArrayList03(int capacity){
if(capacity<0){
throw new RuntimeException("索引不合法！"+ "---------"+capacity);
}else if(capacity ==0 || capacity ==1){
elementData = new Object[DEFALT_CAPACITY];
}else{
elementData =new Object[capacity];
}
}
public void add(E object){
/*什么时候扩容？*/
if(size == elementData.length){
/*怎么扩容？*/
Object[] newArray = new Object[elementData.length + (elementData.length>>1)];
System.arraycopy(elementData,0,newArray,0,elementData.length);
elementData = newArray;//将地址传回老数组
/*垃圾自动回收*/
}
elementData[size++] = object;
}
public int size(){
return this.size;
}
public boolean isEmpty(){
return size == 0;
}
public void remove(Object element){
//element ,將它和所有元素做比較，獲得的第一個爲true的，返回。
for(int i=0; i<size;i++){
if(element.equals(get(i))){ //容器中所有的比較都是equails方法
//將該元素從此處移除
remove(i);
}
}
}
public void remove(int index){
//a,b,c,d,e
//a,c,d,e
int numMoved = elementData.length-index-1;
if(numMoved>0){
System.arraycopy(elementData,index+1,elementData,index,numMoved);
//拷貝哪個數組/從哪裏開始拷貝/拷贝给谁/到那个位置/拷贝多少个
elementData[size-1] = null;
}else{
elementData[size-1] = null;
}
}
public Object get(int index){
checkRange(index);
return elementData[index];
}
public boolean set(E element,int index){
checkRange(index);
elementData[index] = element;
return true;
}
public void checkRange(int index){
if(index<0||index>size){
throw new RuntimeException("索引不合法！"+ "---------"+index);
}
}
/*重写toString() 方法*/
@Override
public String toString(){
StringBuilder sb = new StringBuilder();
sb.append("[");
for(int i=0; i<size ;i++){
sb.append(elementData[i]).append(",");
}
// sb.append("]");
sb.setCharAt(sb.length()-1,']');
return sb.toString();
}
public static void main(String[] args) {
ArrayList<String> s2 = new ArrayList<String>();
SxtArrayList03<String> s1 = new SxtArrayList03<String>(1);
// s1.add("aa");
// s1.add("bb");
// s1.add("cc");
for(int i =1;i<=40;i++){
s1.add("hojay"+i);
}
System.out.println(s1.size);
System.out.println(s1.get(10));
System.out.println(s1.toString());
System.out.println(s1.set("10",10));
s1.remove(2);
System.out.println(s1.toString());
System.out.println(s1.size());
System.out.println(s1.isEmpty());
/*System.out.println(s1);*/
}
}
扫一扫
1101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
