java 列名 结果集 java列表怎么写

列表

介绍

列表是编程语言中常见的数据结构，使用非常广泛，它可以用来存放同类型的数据。相比于数组，它的空间大小是自动调整的，我们不必在一开始指定列表的大小，直接使用就可以了。

常用操作

初始化列表

List<Integer> list1 = new ArrayList<>();

Integer[] nums = new Integer[] {1,2,3,4,5};
List<Integer> list1 = new ArrayList<>(nums);

访问与更新元素

int num = list.get(1);

list.set(1,0);

添加、插入、删除元素

list.add(1);

list.add(3,6);

list.remove(3);

遍历列表

三大方法：

1. for循环
2. 强化for
3. 迭代器

拼接两个列表

list.addAll(list2);

实现

public class ListMethod {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("贾宝玉");
        list.add("林黛玉");
        list.add("大帅哥");
        //void add(int index, Object ele)：在index位置插入ele元素
        list.add(1,"韩顺平");
        System.out.println("list= " + list);
        //boolean addAll(int index, Collection eles)：从index位置开始将eles中的所有元素添加进来
        List list2 = new ArrayList();
        list2.add("jack");
        list2.add("tom");
        list.addAll(1, list2);
        System.out.println("list= " + list);
        //int indexOf(Object obj)：返回obj在集合中首次出现的位置
        System.out.println(list.indexOf("ton"));
        //int lastIndexOf(Object obj)：返回obj在集合中末次出现的位置
        list.add("123");
        System.out.println(list.lastIndexOf("123"));
        //Object remove(int index)：移除指定index位置的元素，并返回此元素
        list.remove(0);
        System.out.println("list= " + list);
        //Object set(int index, Object ele)：设置指定index位置的元素为ele，相当于是替换
        list.set(1,"mary");
        System.out.println("list= " + list);
        //List subList(int fromIndex, int toIndex)：返回从fromIndex到toIndex位置的子集合
        System.out.println(list.subList(1,3));
    }
}

栈

介绍

先入后出

常用操作

方法	描述	时间复杂度
push()	入栈	O(1)
pop()	出栈	O(1)
peek()	访问栈顶	O(1)

Stack<Integer> stack = new Stack<>();

stack.push(1);

stack.pop();

stack.isEmpty();

实现

基于链表实现

//创建结点
class Node{
    int value;
    Node next = null;
    //构造器
    Node(int value){
        this.value = value;
    }
}
//创建栈
class MyStack{
    private Node head = null;
    //入栈
    public void push(int element){
        if(head == null){//如果栈是空的
            head = new Node(element);//令栈首为新入的元素
        }else{//如果栈不是空的
            Node last = getLast(head);//得到最后一个结点last
            last.next = new Node(element);//最后一个结点的下一个为新结点
            last.next.next = null;//新节点的下一个节点为null
        }
    }
    private Node getLast(Node node){
        if(node == null){
            return null;
        }
        Node last = head;
        while(node.next != null){
            last = last.next;
        }
        return last;
    }

    //出栈
    public int pop(){
        if(head == null){//栈空
            return -1;
        }

        Node last = getLast(head);//获得倒数第一个元素
        if(head.next == null){//last若为null,最后返回的head就为null
            head = null;
            return last.value;
        }

        Node lastlast = getLastLast(head);//得到倒数第二个元素lastLast
        lastlast.next = null;
        return last.value;
    }

    private Node getLastLast(Node head){
        if(head == null || head.next == null){
            return null;
        }
        Node lastLast = head;
        while (lastLast.next.next != null){
            lastLast = lastLast.next;
        }
        return lastLast;
    }
}

基于数组实现

class MyStack{
    private int maxSize;
    private int top;
    private int[] stack;

    //初始化
    public MyStack(int maxSize) {
        this.maxSize = maxSize;
        this.top = -1;
        this.stack = new int[maxSize];
    }
    //入栈
    public void push(int num){
        if(isFull()){
            System.out.println("满了");
        }else{
            top++;
            stack[top] = num;
        }
    }
    //出栈
    public int pop(){
        if(isEmpty()){
            System.out.println("空栈");
        }
        int value = stack[top];
        top--;
        return value;
    }
}

队列

介绍

先入先出

常用操作

方法名	描述	时间复杂度
push()	入队至队尾	O(1)
poll()	队首出队	O(1)
front()	访问队首	O(1)
size()	获取长度	O(1)
isEmpty()	判断是否为空	O(1)

实现

基于链表实现

class Node{
    Object value;
    Node next;

    public Node(Object value){
        this.value = value;
        next = null;
    }
    public void setNext(Node next){
        this.next=next;
    }
}
class MyQueue{
    private Node front;
    private Node rear;
    int size;
    int maxSize;

    //初始化
    public MyQueue(){
        front = rear = null;
        size = 0;
    }

    //插入
    public void put(Node e){
        if(size==0){
            front = rear = new Node (e);
        }else{
            rear.setNext(new Node (e));
            rear = rear.next;
        }
        size++;
    }
    //删除
    public Node take(){
        if(size==0){
            System.out.println("空的");
        }
        Node e = (Node) front.value;
        front = front.next;
        if(front == null){
            rear = null;
        }
        size--;
        return e;
    }
}

基于数组实现

class MyQueue{
    private String[] items;//数组
    private int n = 0;//数组大小
    private int head = 0;//头的下标
    private int tail = 0;//尾的下标
    
    //初始化
    public MyQueue(int capacity){
        items = new String[capacity];
        n = capacity;
    }
    
    //入队
    public boolean enqueue(String item){
        if(tail == n){//队尾等于长度，满了
            return false;
        }
        items[tail] = item;
        tail++;
        return true;
    }
    //出队，同时返回队首
    public String dequeue(){
        if(head == tail){
            return null;
        }
        String ret = items[head];
        head ++;
        return ret;
    }
}