蓝桥杯快到了，Java的这些常用方法一定要知道_蓝桥杯常用函数java

前言

一年一度的蓝桥杯还有不到10天就到了，我们除了在算法方面要进行练习之外，对于一些基本的api也要熟记，因为这也是重点，是我们会用到的东西。

1. 数组

1.1 实例化数组

//声明数组变量
String [] arr;
int arr1[];
//数组对象实例化（长度为6）
String[] array = new  String[6];
int score[] = new  int[6];
1
2
3
4
5
6

1.2 初始化数组；

//静态初始化
int  arr[]= new  int []{1, 2, 3, 4, 5};
String[] array1={ "马超" , "马云" , "马可"};
String[] array2= new  String[]{"吕布", "奉先", "三姓家奴", "猛将"};
//动态初始化
int  score[]= new  int [ 3 ];
for (int i = 0; i < score.length; i ++) {   
　　score[i]=i + 1 ; 
}
1
2
3
4
5
6
7
8
9

1.3 求数组长度

int  length = array1.length;
1

1.4 遍历打印数组

for  ( int  i =  0 ; i < array1.length; i++) {
     System.out.println(array1[i]);
}
1
2
3

1.5 int数组转成字符串string

String arrStrings = Arrays.toString(array);
1

1.6 从Array中创建Arraylist

String[] array1={"马超" , "马云" , "马可"};
ArrayList<String> arrayList= new  ArrayList(Arrays.asList(array1));
System.out.println(arrayList);
1
2
3

1.7 contains()查询数组中是否包含某一个值

String a= "马超" ;
String[] array1={ "马超" , "马云" , "关羽" , "刘备" , "张飞" };
if (Arrays.asList(array1).contains(a)) {
     System.out.println( "马超在这里" );
}
1
2
3
4
5

1.8 将数组转成set集合

String[] array2= new  String[]{"吕布", "奉先", "三姓家奴", "猛将"};
Set<String> set= new  HashSet(Arrays.asList(array2));
System.out.println(set);
1
2
3

1.9 将数组转成list集合

//方法 1.
String[] array2= new  String[]{"吕布", "奉先", "三姓家奴", "猛将"};
List<String> list= new  ArrayList<String>();
for(int i = 0; i < array2.length; i ++) {
     list.add(array2[i]);
}
//方法 2.
String[] arrStrings2={ "1" , "2" , "3" };
List<String> list2 = Arrays.asList(arrStrings2);
System.out.println(list2);
1
2
3
4
5
6
7
8
9
10

1.10 Arrays.fill()填充数组

//将数组全部填充10
Arrays.fill(arr, 10);   
1
2

1.11 数组排序；

//方法1:sort(int[] a)   放入数组名字
Arrays.sort(arr);
//方法2:sort(a, fromIndex, toIndex)  从第几个到第几个之间的进行排序
Arrays.sort(arr, 1 , 4);
1
2
3
4

1.12 复制数组

//方法 1
int [] arr6 = {3, 7, 2, 1};
//指定新数组的长度
int [] arr7 = Arrays.copyOf(arr6,  10 );  
//方法 2
//只复制从索引[1]到索引[3]之间的元素（不包括索引[3]的元素）     
int [] arr8 = Arrays.copyOfRange(arr6, 1, 3);  
for  (int i = 0; i < arr8.length; i ++) {
        System.out.println(arr8[i]);
}
1
2
3
4
5
6
7
8
9
10

1.13 数组去重复

int [] arr11 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 3, 2, 4, 5, 6, 7, 4};
//利用set的特性
Set<Integer> set2= new  HashSet();
for (int i = 0; i < arr11.length; i ++) {
     set2.add(arr11[i]);
}
System.out.println(set2);
int[] arr12 = new  int[set2.size()];
int j = 0;
for (Integer i : set2) {
     arr12[j++]=i;
}
System.out.println(Arrays.toString(arr12));
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 栈

2.1 实例化栈

Stack<E> stack = new Stack();
1

2.2 判断是否为空

stack.empty()
1

2.3 取栈顶值（不出栈）

stack.peek()
1

2.4 入栈

//方法1：将元素加入栈顶，并返回栈顶元素
stack.push(Object);
//方法2:也是向栈顶添加一个元素，返回值为true
stack.add(Object);
1
2
3
4

2.5 出栈

stack.pop();
1

2.6 栈中元素的个数

stack.size();
1

2.7 查找元素在栈中的位置（以1开始，由栈底向栈顶方向数）

stack.search(Object);
1

3. 队列

3.1 实例化队列

 Queue<E> queue = new LinkedList();
1

3.2 进队列，将元素加入队列末尾

queue.offer(Object);
1

3.3 获取队列头的元素

queue.peek();
1

3.4 获取队列头的元素并移除

queue.poll();
1

3.5 判断是否为空

queue.isEmpty() 
1

4. List

4.1 实例化List

List<E> list = new ArrayList();
1

4.2 list中添加元素

list.add(Object);
1

4.3 依靠元素下标获取元素

list.get(index);
1

4.4 list中删除元素

//按照索引删除
list.remove(index);
//按照元素内容删除
list.remove(Object);
1
2
3
4

4.5 list中是否包含某个元素（返回true或者false）

list.contains(Object);
1

4.6 list中查看对于元素的索引

list.indexOf(Object);
1

4.7 将集合转换为字符串

list.toString();
1

4.8 集合转换为数组

list.toArray();
1

4.9 集合元素去重复

List<String> list= new  ArrayList<>();
list.add( "aa" );
list.add( "ss" );
list.add( "aa" );
list.add( "ss" );
 
//方法 1.
for  ( int  i =  0 ; i <list.size()- 1 ; i++) {
    for  ( int  j = list.size()- 1 ; j >i; j--) {
       if  (list.get(j).equals(list.get(i))) {
            list.remove(j);
         }
     }
}
System.out.println(list);
             
//方法 2.
List<String> list = new  ArrayList<>();
for (String s : list) {
     if  (Collections.frequency(list, s) < 1 ) {
          list.add(s);
     }
}
System.out.println(list);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

5.Map

5.1 实例化Map

Map<E1, E2> map = new HashMap();
1

5.2 清空Map

map.clear(); 
1

5.3 判断该集合是否为空

map.isEmpty();
1

5.4 获取Map中键值对的个数

map.size();
1

5.5 向集合中添加键值对

map.put(Object key, Object value); 
1

5.6 通过key获取value

map.get(Object key);
1

5.7 判断Map中是否包含这样的key

map.containsKey(Object key);
1

5.8 判断Map中是否包含这样的value

map.containsValue(Object value); 
1

5.9 通过key将键值对删除

map.remove(Object key);
1

5.10 获取Map集合中所有的value

map.values();
1

5.11 获取Map中所有的key

map.keySet(); 
1

结语

祝大家蓝桥杯取得一个好成绩！

---

算法对程序员来说及其重要，语言和开发平台不断变化，但是万变不离其宗的是那些算法和理论，刷算法最最最直白的原因就是找一个好的工作，那刷题一定是必不可少的就是一个好的刷题平台。现在算法刷题平台鱼龙混杂，非常多。如何选择一个正确的刷题平台呢？

这里我推荐牛客网如果你对相应语言的基础语法已经比较自信了那你也可以刷算法题，这里牛客网对算法题的难度分类也是很棒的，有入门题，面试必刷题，面试高频题等等。如果基础比较差那么也不用担心，牛客网上面也有基础语法题来帮助你更好地学习基础。

为了大家方便刷题我直接把牛客网的链接放在下面，大家点击蓝色字体就可以直接进行跳转刷题了！

传送门：刷题入口

刷题这件事，大家一定要认真起来，不可懈怠！

日积月累，方成大器！