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转为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

char数组转为String

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 互转

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类型。

int转为String

int intValue = 456;
String str = Integer.toString(intValue);
System.out.println("整数转换为字符串：" + str);

或者使用String.valueOf()方法：

int intValue = 789;
String str = String.valueOf(intValue);
System.out.println("整数转换为字符串：" + str);

Char 和 int 互转

char 转为int  （‘2’ ----> 2）

char charDigit = '2';
int intDigit = charDigit - '0';
System.out.println("字符 '2' 转换为整数: " + intDigit);

int 转为char （2 ----> '2'）

int intDigit = 2;
char charDigit = (char)(intDigit + '0');
System.out.println("整数 2 转换为字符: " + charDigit);

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常用的几个方法：

A：添加功能
  public StringBuffer append(String str):
可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身  

        public StringBuffer insert(int offset,String str):
在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

B：删除功能
  public StringBuffer deleteCharAt(int index)
删除指定位置的字符，并返回本身  

        public StringBuffer delete(int start,int end)
删除从指定位置开始指定位置结束的内容，并返回本身

C：替换功能
  public StringBuffer replace(int start,int end,String str)
从start开始到end用str替换

D：反转功能
  public StringBuffer reverse()

E：截取功能
  public String substring(int start)
  public String substring(int start,int end)

　　

关于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（）