Java数据类型api记录

关于数组的一些用法

1. 数组排序

Java中可以使用Arrays类的sort()方法对数组进行排序。

Arrays.sort(arr); // 调用Arrays类的sort()方法对数组进行排序

关于ArrayList的用法

1. 将几个零散的数值转化为ArrayList

Arrays.asList(nums[i], nums[left], nums[right])

Arrays.asList() 方法返回的并不是 java.util.ArrayList ，而是 java.util.Arrays 的一个内部类 

2. 数组转集合

有坑！！！

Arrays.asList()

    public static void main(String[] args) {
        String[] strs = {"aaa", "bbb", "ccc"};
        List<String> list = Arrays.asList(strs);
        System.out.println(list);    // [aaa, bbb, ccc]
 
        int[] arr1 = {1,2,3};
        List<int[]> ints = Arrays.asList(arr1);
        System.out.println(ints);   // [[I@4554617c]
 
        Integer[] arr2 = {4,5,6};
        List<Integer> list1 = Arrays.asList(arr2);
        System.out.println(list1);    // [4, 5, 6]
 
        list1.add(7); // 报错java.lang.UnsupportedOperationException
    }

第一点：Arrays.asList()是泛型方法，传递的数组必须是对象数组，而不是基本类型

第二点：当传入一个基本数据类型数组时，Arrays.asList() 的真正得到的参数就不是数组中的元素，而是数组对象本身！此时 List 的唯一元素就是这个数组，这也就解释了上面的代码

第三点：使用集合的修改方法: add()、remove()、clear()会抛出异常。Arrays.asList() 方法返回的并不是 java.util.ArrayList ，而是 java.util.Arrays 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。

那我们如何正确的将数组转换为 ArrayList?

1、手动实现工具类:  就是遍历数组，然后一个个add();

2. 最简便的方法

List list = new ArrayList<>(Arrays.asList("a", "b", "c"))

3. stream流

Integer [] myArray = { 1, 2, 3 };
List myList = Arrays.stream(myArray).collect(Collectors.toList());
//基本类型也可以实现转换（依赖boxed的装箱操作）
int [] myArray2 = { 1, 2, 3 };
List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList());

3. 集合转数组 

使用集合转数组的方法，必须使用集合的 toArray(T[] array)，传入的是类型完全一致、长度为 0 的空数组
toArray(T[] array) 方法的参数是一个泛型数组，如果 toArray 方法中没有传递任何参数的话返回的是 Object类 型数组。

String [] s= new String[]{
    "dog", "lazy", "a", "over", "jumps", "fox", "brown", "quick", "A"
};
List<String> list = Arrays.asList(s);
Collections.reverse(list);
//没有指定类型的话会报错
s=list.toArray(new String[0]);

由于 JVM 优化，new String[0]作为Collection.toArray()方法的参数现在使用更好，new String[0]就是起一个模板的作用，指定了返回数组的类型，0 是为了节省空间，因为它只是为了说明返回的类型

关于String的一些用法

String 和 char数组互转

String s = "helloworld"
char[] ch = s.toCharArray();
 
 
char[] charArray = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};
String str = new String(charArray);
System.out.println(str); // 输出: Hello World

1. 使用 String 构造函数：

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str = new String(charArray);
System.out.println(str); // 输出: Hello

 2. 使用 String 类的 valueOf() 静态方法：

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str = String.valueOf(charArray);
System.out.println(str); // 输出: Hello

String 转为int

public class Main {
    public static void main(String[] args) {
        String str = "123";
        
        // 使用 parseInt() 方法
        int intValue1 = Integer.parseInt(str);
        System.out.println(intValue1); // Output: 123
        
        // 使用 valueOf() 方法
        int intValue2 = Integer.valueOf(str);
        System.out.println(intValue2); // Output: 123
    }
}

这两种方法的区别在于：

• parseInt() 方法将字符串转换为int基本类型。
• valueOf() 方法将字符串转换为Integer对象，然后通过自动拆箱将其转换为int类型。

charAt() 获取指定字符

String str = "This is CSDN";
        
// prints character at 1st location
System.out.println(str.charAt(0));
     
// prints character at ths last location
System.out.println(str.charAt(str.length()-1));

trim() 去除字符串首位的空格

String Str = "    hello     ";
System.out.print("原始值 :" );
System.out.println( Str );
 
System.out.print("删除头尾空白 :" );
System.out.println( Str.trim() );

split() 分割字符串

String str="2018,text,今天";
//单个分隔符用引号括起来即可
String[] data = str.split(",");
for(int i=0;i< data.length;i++){
     System.out.println(data[i]);
}

StringBuffer

StringBuffer s = new StringBuffer();　　　//空的对象
 
StringBuffer s1 = new StringBuffer("abc");　//有内容的对象

StringBuffer常用的几个方法：

　　1、append（）

　　　　：连接字符串

　　2、deleteCharAt（int index）

　　　　:删除指定位置的字符，之后变成一个心得字符串

　　3、insert（int index,字符串）

　　　　：将"字符串"插入到指定索引值处

关于map的一些用法

Map<Character, Integer> map = new HashMap<>();
 
map.containsKey(c2);
 
map.getOrDefault(c1,0);
 
map.put(c1, map.getOrDefault(c1,0) + 1);
 
 

遍历map的方法

1. entrySet

entrySet是java中 键-值对的集合，Set里面的类型是Map.Entry，一般可以通过map.entrySet()得到。

• entrySet实现了Set接口，里面存放的是键值对。一个K对应一个V。

System.out.println("通过Map.entrySet遍历key和value");
 
Set<Map.Entry<String, String>> entryseSet=map.entrySet();
 
for (Map.Entry<String, String> entry:entryseSet) {
 
    System.out.println(entry.getKey()+","+entry.getValue());
 
}
 
// 即通过getKey（）得到K，getValue得到V。

2. keySet

还有一种是keySet, keySet是键的集合，Set里面的类型即key的类型

System.out.println("通过Map.keySet遍历key和value：");
 
Set<String> set = map.keySet();
 
for (String s:set) {
 
    System.out.println(s+","+map.get(s));
 
}

3. 通过Map.values()遍历所有的value，但不能遍历key

//第四种
System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
for (String v : map.values()) {
    System.out.println("value= " + v);
}

关于set的一些用法

Set<String> testSet = new HashSet<String>();
 
testSet.add("Java");
 
set1.contains(i)  // 很好用 效率高

数组和Set互转  

常用方法 数组转为Set
        由于nums1是int[ ]  居然会报错! 

Set<Integer> set1 = new HashSet<>(Arrays.asList(nums1));

 现在知道为什么会报错了 因为Set只能存储对象类型的参数

注意：

数组转为set  就老老实实遍历吧！

Set<Integer> set1 = new HashSet<>();
for(int num : nums1){
    set1.add(num);
}

set 转为数组 也就老老实实一个个填吧！

Set<Integer> res = new HashSet<>();
int[] result = new int[res.size()];
int j = 0;
for(Integer num : res){
    result[j++] = num;
}

当然可以使用更加高级的stream流

resSet.stream().mapToInt(x -> x).toArray();

Java实现栈和队列

1. 实现栈

Stack<Integer> stack = new Stack<>();
 
push();   // 入栈
 
pop();    // 出栈
 
peek();   // 返回栈顶元素
 
isEmpty();  // 判断是否为空
 
size();    // 返回大小
 
 
此外双端队列也可以实现栈
 
Deque<Character> deque = new LinkedList<>();
ArrayDeque<Character> deque = new ArrayDeque<>(); 
//ArrayDeque会比LinkedList在除了删除元素这一点外会快一点
//事实上，Deque 还提供有 push() 和 pop() 等其他方法，可用于模拟栈。
 
push();   // 入栈
 
pop();    // 出栈
 
peek();   // 返回栈顶元素
 
isEmpty();  // 判断是否为空
 
size();    // 返回大小

2.实现队列

Queue<Integer> queue = new LinkedList<>();
 
queue.offer();   // 入队
    
queue.poll();    // 出队
 
queue.peek();   // 返回头元素
 
queue.isEmpty();  // 判断是否为空
 
queue.size();  // 返回大小

优先级队列实现大根堆和小根堆 (比如一些问题 求第k大的数 果断使用大根堆来处理)

Comparator接口说明:
 返回负数，形参中第一个参数排在前面；返回正数，形参中第二个参数排在前面
 
// 实现小根堆
PriorityQueue<Integer> queue = new PriorityQueue<>((o1, o2) -> o1 - o2);
 
// 实现大根堆
PriorityQueue<Integer> queue = new PriorityQueue<>((o1, o2) -> o2 - o1);
 
queue.offer();
 
queue.poll();
 
queue.isEmpty();
 
queue.peek();
 
queue.size（）