Collection集合(中) -- vector，stack

 

Collection

List（列表）

Vector

Java的第一个集合

Vector：Java出现第一个出现的集合，底层基于数组实现的，默认初始容量是10，默认的扩容是增大一倍（可以指定初始容量以及增量（指定扩容的大小）），是一个线程安全的集合

import java.util.Vector;
​
/*
 * 实现LinkedList
 */
public class VictorDemo {
    public static void main(String[] args) {
        //（指定初始容量，增量（指定每次扩容的大小））
        Vector<String> vd = new Vector<>(5,5);
        //
        for (int i = 0; i <7; i++) {
            vd.add("a");
        }
        System.out.println(vd.capacity());
    }
}

 

 

Vector中迭代器的使用

import java.util.Enumeration;
import java.util.Vector;
​
public class VictorDemo {
    public static void main(String[] args) {
        Vector<String> vd = new Vector<>();
        //
        vd.add("a");
        vd.add("b");
        vd.add("v");
        vd.add("g");
        vd.add("y");
        //获取迭代器，通过调用方法（element只在Vector中）
        Enumeration<String> e = vd.elements();
        
        //判断是否还有元素
        while(e.hasMoreElements()){
            //获取元素
            String s = e.nextElement();
            //输出字符串
            System.out.println(s);
        }
        
    }
}

 

 

Iterator迭代器

　　底层通过指针的挪动来进行集合元素的遍历

　　在遍历期间不能增删原集合

　　Iterator方法是Iterable接口提供的，

　　一个对象提供的类实现了iterable接口，就能进行增强for循环，增强for循环底层由迭代器进行遍历 ------------- jdk1.5新特性

import java.util.ArrayList;
import java.util.Iterator;
​
public class IteratorDemo {
    public static void main(String[] args) {
        //
        ArrayList<String> list = new ArrayList<String>();
        //
        list.add("A");
        list.add("F");
        list.add("G");
        list.add("H");
        list.add("J");
        
        //获取迭代器
        Iterator<String> it=list.iterator();
        
        //判断是否有元素
        while(it.hasNext()){
            //获取元素
            String s = it.next();
            
            //循环将每个元素变为false，遍历完成后删除false的内容
            ///不能直接增删原集合
            //可以通过迭代器对象遍历的标记值进行间接删除集合的元素
            it.remove();
            //输出元素  
            System.out.println(s);      
        }
        
        System.out.println(list);   // []
        
    }
}

 

对集合内容进行排序

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
​
public class ComparatorDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("5s");
        list.add("dsaf");
        list.add("ddd");
        
        //Comparator---比较器
        list.sort(new Comparator<String>() {
            //比较规则写在重写方法中
            //如果返回的是正数，前面的对象大于后面的数
            //如果返回的是负数，前面的对象小于后面的数
            //如果是0,表明两个对象元素值相等
            //想以首字母顺序进行排序（升序）
            @Override
            public int compare(String o1, String o2) {
​
                return o1.charAt(0)-o2.charAt(0);
            }
        });
        System.out.println(list);
    }
}

 

stack

　　是Vector的子类，遵循后进先出（LIFO）的原则

　　栈顶元素：最后一个进入的元素

　　栈底元素：第一个进入栈的元素

　　压栈/入栈：元素进入栈中

　　弹栈/出栈：元素从栈中拿出

import java.util.Stack;
​
public class StackDemo {
    public static void main(String[] args) {
        //创建Stack的对象
        Stack<String> s = new Stack<>();
        //添加元素 --- 入栈
        s.push("a");    //栈低
        s.push("f");
        s.push("h");
        s.push("g");
        s.push("x");    //栈顶
        
        //判断栈是否为空
        System.out.println(s.isEmpty());    //false
        
        //获取栈顶元素，不删除
        //如果是空栈，则抛出Exception
        System.out.println(s.peek());       //x
    
        //获取栈顶元素，删除
        System.out.println(s.pop());        //x
        
        //保证存入的顺序
        System.out.println(s);              //[a, f, h, g]
        
        //从栈顶一次往下查找，是否有相同元素，返回一个整型值，从1开始计数
        System.out.println(s.search("g"));  //1
    }
}

用数组实现Stack​

import java.util.Arrays;
import java.util.EmptyStackException;
​
public class StackDemo {
    public static void main(String[] args) {
        stack s = new stack();
        s.push("a");
        s.push("b");
        s.push("f");
        s.push("g");
        System.out.println(s.size);
        System.out.println(s.empty());
        System.out.println(s.peek());
        System.out.println(s);
    }
}
​
class stack {
    // 存储数据的数组
    String[] date;
    // 元素的下标
    int size = 0;
​
    // 无参构造
    public stack() {
        date = new String[10];
    }
​
    // 判断栈是否为空
    public boolean empty() {
        return size==0;
    }
​
    //获取栈顶元素
    //栈为空就报错
    public String peek(){
        if(size<=0){
            throw new EmptyStackException();
        }
        return date[size-1];
    }
    
    //获取栈顶元素,删除此元素
    public String pop(){
        //获取栈顶元素
        String str = peek();
        //删除此元素
        size--;
        //返回
        return str;
    }
    
​
    // 压栈
    public void push(String str) {
        //判断是否需要扩容操作
        if(size>=date.length){
            //默认扩容一倍
            date= Arrays.copyOf(date, date.length*2);
        }
        
        //把参数元素放入栈中
        date[size++]= str;
        
    }
    
//  查找
    public int search(String str){
        for(int i=size-1;i>=0;i--){
            //循依次拿元素的值和参数进行比较
            if(str==date[i]||str!=null&&str.equals(date[i])){
                return size-1;
            }
        }
        
        //没找到
        return -1;
    }
    
    //拼接，重写toString方法
    @Override
    public String toString(){
        //创建对象进行拼接
        StringBuilder sb = new StringBuilder("[");
        //遍历数组元素进行拼接
        for(int i= 0; i<size;i++){
            sb.append(date[i]).append(", ");
        }
        
        //转成字符串
        String str = sb.toString();
        
        //截取子串
        if(size>0){
            str = str.substring(0,str.length()-2);
        }
        return str+="]";
    }
}