java 常用操作

1、数组求和

int sumRolls = Arrays.stream(rolls).sum();

 

2、java 获取用键盘输入常用的两种方法

方法 1：通过 Scanner

1 Scanner input = new Scanner(System.in);
2 String s  = input.nextLine();
3 input.close();

 

方法 2：通过 BufferedReader

1 BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
2 String s = input.readLine();

 

3、栈

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

interface MyStack {
    public void clear();

    public boolean empty();//判断栈是否为空

    public Object peek();// 查看堆栈顶部的对象，但不从堆栈中移除它。

    public void push(Object x);// 向栈顶添加元素

    public Object pop();// 移除堆栈顶部的对象，并作为此函数的值返回该对象。

    int search(Object element); //返回对象在堆栈中的位置，以 1 为基数。
}

 

4、队列

    public void test(){
        Queue<Integer> q = new LinkedList<>();
        boolean add = q.add(1);
        boolean offer = q.offer(1);
        Integer remove = q.remove();
        Integer poll = q.poll();
        q.add(2);
        q.peek();
        q.element();
        int size = q.size();
    }

 

优先队列

    public void test(){
        Queue<Integer> q = new PriorityQueue<>();
        Queue<Integer> qq = new PriorityQueue<>(cmp);
        qq.add(1);
        qq.add(3);
        qq.add(2);
        while(qq.size() > 0){
            System.out.println(qq.poll());
        }
    }

    //自定义比较器，降序排列
    static Comparator<Integer> cmp = (e1, e2) -> e2 - e1;

    static Comparator<Integer> cmp2 = new Comparator<Integer>() {
        public int compare(Integer e1, Integer e2) {
            return e2 - e1;
        }
    };

 

双端队列

        Deque<Integer> deque = new ArrayDeque<Integer>();
        Deque<Integer> deque2 = new LinkedList<>();

 

 

5、list

public void test() {
        List<Integer> a = new ArrayList<Integer>();
        a.size();
        a.add(1);
        a.addAll(Arrays.asList(1,2,3,4,5,6));
        a.remove(1);
        a.remove((Object)2);
        a.get(2);
        a.contains(3);
        a.stream().forEach(System.out::println);
    }

List< Integer > 转 Integer[ ]

Integer[] integers = list.toArray(new Integer[list.size()]);

List< Integer > 转 int[ ]

int[] arr2 = list.stream().mapToInt(Integer::valueOf).toArray();

Integer[ ]转 int[ ]

int[] arr= Arrays.stream(integers).mapToInt(Integer::valueOf).toArray();

 

6、map

    public void test() {
        Map<String, Integer> mp = new HashMap<>();
        Map<String, Integer> mp2 = new HashMap<>();
        mp.put("hello", 7);
        mp2.put("world", 7);
        mp.putAll(mp2);
        boolean hello = mp.containsKey("hello");
        boolean b = mp.containsValue(7);

        for(Map.Entry<String, Integer> entry : mp.entrySet()){
            String mapKey = entry.getKey();
            Integer mapValue = entry.getValue();
            System.out.println(mapKey+":"+mapValue);
        }

        for(String key : mp.keySet()){
            System.out.println(key);
        }

        for(Integer value : mp.values()){
            System.out.println(value);
        }

        Iterator<Map.Entry<String, Integer>> entries = mp.entrySet().iterator();
        while(entries.hasNext()){
            Map.Entry<String, Integer> entry = entries.next();
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+":"+value);
        }

        //通过键找值遍历，这种方式的效率比较低，因为本身从键取值是耗时的操作；
        for(String key : mp.keySet()){
            Integer value = mp.get(key);
            System.out.println(key+":"+value);
        }

 

 

为什么：//通过键找值遍历，这种方式的效率比较低，因为本身从键取值是耗时的操作；

 

 

7、set

    public void test() {
        Set<Integer> s = new HashSet<>();
        s.add(1);
        s.add(2);
        s.add(3);
        s.contains(1);
        s.remove(1);
        System.out.println(Arrays.toString(s.toArray()));// [2,3]
    }