java 常用操作

1、数组求和

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、栈

 1 Stack<Integer> st = new Stack<>();
 2 
 3 interface MyStack {
 4     public void clear();
 5 
 6     public boolean empty();//判断栈是否为空
 7 
 8     public Object peek();// 查看堆栈顶部的对象，但不从堆栈中移除它。
 9 
10     public void push(Object x);// 向栈顶添加元素
11 
12     public Object pop();// 移除堆栈顶部的对象，并作为此函数的值返回该对象。
13 
14     int search(Object element); //返回对象在堆栈中的位置，以 1 为基数。
15 }

4、队列

 1     public void test(){
 2         Queue<Integer> q = new LinkedList<>();
 3         boolean add = q.add(1);
 4         boolean offer = q.offer(1);
 5         Integer remove = q.remove();
 6         Integer poll = q.poll();
 7         q.add(2);
 8         q.peek();
 9         q.element();
10         int size = q.size();
11     }

优先队列

 1     public void test(){
 2         Queue<Integer> q = new PriorityQueue<>();
 3         Queue<Integer> qq = new PriorityQueue<>(cmp);
 4         qq.add(1);
 5         qq.add(3);
 6         qq.add(2);
 7         while(qq.size() > 0){
 8             System.out.println(qq.poll());
 9         }
10     }
11 
12     //自定义比较器，降序排列
13     static Comparator<Integer> cmp = (e1, e2) -> e2 - e1;
14 
15     static Comparator<Integer> cmp2 = new Comparator<Integer>() {
16         public int compare(Integer e1, Integer e2) {
17             return e2 - e1;
18         }
19     };

双端队列

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

5、list

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

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

 1     public void test() {
 2         Map<String, Integer> mp = new HashMap<>();
 3         Map<String, Integer> mp2 = new HashMap<>();
 4         mp.put("hello", 7);
 5         mp2.put("world", 7);
 6         mp.putAll(mp2);
 7         boolean hello = mp.containsKey("hello");
 8         boolean b = mp.containsValue(7);
 9 
10         for(Map.Entry<String, Integer> entry : mp.entrySet()){
11             String mapKey = entry.getKey();
12             Integer mapValue = entry.getValue();
13             System.out.println(mapKey+":"+mapValue);
14         }
15 
16         for(String key : mp.keySet()){
17             System.out.println(key);
18         }
19 
20         for(Integer value : mp.values()){
21             System.out.println(value);
22         }
23 
24         Iterator<Map.Entry<String, Integer>> entries = mp.entrySet().iterator();
25         while(entries.hasNext()){
26             Map.Entry<String, Integer> entry = entries.next();
27             String key = entry.getKey();
28             Integer value = entry.getValue();
29             System.out.println(key+":"+value);
30         }
31 
32         //通过键找值遍历，这种方式的效率比较低，因为本身从键取值是耗时的操作；
33         for(String key : mp.keySet()){
34             Integer value = mp.get(key);
35             System.out.println(key+":"+value);
36         }

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

7、set

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