数据结构Api

数据结构Api

Arrays

排序

Arrays.sort(int[] arr, int fromIndex, int toIndex, 比较器);   //一定是需要泛型

Arrays.sort(arr, (o1, o2) -> o2 - o1);   //数组全部 从大到小排序 跟Collections.sort()一样

Arrays.sort(arr, 0, 3, (o1, o2) -> o2 - o1);   //从大到小排序，只排序[0, 3)

列表

注意，ArrayList的扩容 需要将旧的数组的元素复制到新的数组，时间复杂度为O(n)

两种实现，ArrayList利于查找，LinkedList 利于增删。

List<Integer> list = new ArrayList<> ();
   // 添加元素
   list.add (1);
   list.add (2);
   list.add (5);
   list.add (6);
   System.out.println (list);
   // 移除 index = 1 的元素
   list.remove (1);
   System.out.println (list);
   // 移除元素 1 
   list.remove(Integer.valueOf (1));
   System.out.println (list);


   // 判断是否包含某个元素
   boolean contains = list.contains (6);
   System.out.println (contains);
   
   // 获取元素的个数
   int size = list.size ();
   System.out.println (size);

   // 判断是否为空
   boolean isEmpty = list.isEmpty ();
   System.out.println (isEmpty);
   
   //  获取 index = 1 的元素
   Integer res = list.get (1);
   System.out.println (res);
   
   // 清空 list
   list.clear ();
   System.out.println (list);

栈

        LinkedList<Integer> stack=new LinkedList<> ();
        // 加入元素
        stack.push (1);
        stack.push (3);
        stack.push (5);
        stack.push (2);
        System.out.println(stack);
        
        // 弹出元素
        Integer popVal = stack.pop ();
        System.out.println (popVal);
        System.out.println (stack);
        
        // 栈大小
        System.out.println (stack.size ());
        // 栈顶元素
        System.out.println (stack.peek ());
        // 判断栈是否为空
        System.out.println (stack.isEmpty ());

队列

        LinkedList<Integer> queue=new LinkedList<> ();
        // 加入元素
        queue.offer (1);
        queue.offer (5);
        queue.offer (3);
        queue.offer (2);
        System.out.println (queue);

        // 弹出 队头元素
        Integer pollVal = queue.poll ();
        System.out.println (pollVal);
        System.out.println (queue);

        // 查看 队头元素
        System.out.println (queue.peek ());

        // 判断是否为空
        System.out.println (queue.isEmpty ());
        // 获取队列长度
        System.out.println (queue.size ());

双向队列

      LinkedList<Integer> queue=new LinkedList<> ();
        // 加入元素
        queue.offerFirst (1);
        queue.offerFirst (3);
        queue.offerLast (5);
        queue.offerLast (8);
        System.out.println (queue) ; //  3 1 5  8
        System.out.println (queue.pollFirst ()) ; // 3
        System.out.println (queue) ;

        System.out.println (queue.pollLast ()); // 8
        System.out.println (queue);

        // 队列长度
        System.out.println (queue.size ());
        // 判断队列是否为空
        System.out.println (queue.isEmpty ());

        // 查看 左侧队头
        System.out.println (queue.peekFirst ());
        // 查看 右侧队头
        System.out.println (queue.peekLast ());

优先队列

在Java中的实现是 PriorityQueue ，底层是一棵树， 以小根堆为例。对于任意结点来说，该节点的值比其左右孩子的值都要小。 （就是最上面的结点最小）。 大根堆类似，最上面结点最大

// 小根堆
PriorityQueue<Integer> queue = new PriorityQueue<> ((a, b) -> a - b);
// PriorityQueue<Integer> queue = new PriorityQueue<> (100,(a, b) -> a - b);
// 加入元素
queue.offer (1);
queue.offer (5);
queue.offer (3);
queue.offer (2);
System.out.println (queue);

// 获取 堆顶元素
Integer pollVal = queue.poll ();
System.out.println (pollVal); // 1
System.out.println (queue);

// 查看堆顶元素
System.out.println (queue.peek ());
// 判断堆是否为空
System.out.println (queue.isEmpty ());
// 查看堆大小
System.out.println (queue.size ());

Set

/**
  * Set集合是一种 不允许有重复元素的集合
  *    无序的
  *    无索引
  *    不能有重复元素
  *    允许有一个null
  */
 HashSet<Integer> set = new HashSet<> ();
 set.add (1);
 set.add (2);
 set.add (null);
 set.add (2);
 set.add (3);
 set.add (4);
 
 // 打印Set集合
 System.out.println (set);
 int size = set.size ();
 
 // 打印Set集合的大小
 System.out.println (size);

 boolean empty = set.isEmpty ();
 
 // 打印Set集合是否为空
 System.out.println (empty);
 
 boolean contains = set.contains (1);
 System.out.println (contains);
 
 // 移除指定元素
 set.remove (1);
 System.out.println (set);
 
 // 清空Set集合
 set.clear ();

Map

// HashMap 无序
// 可存储自定义对象
Map<String, Integer> map = new HashMap<> ();
// 添加元素 put
map.put ("小米", 2000);
map.put ("华为", 3000);
map.put ("苹果", 5000);
System.out.println (map);

/**
 * 键 不存在,直接添加键值对
 * 键 存在,覆盖
 */
map.put ("苹果", 6000);
System.out.println (map);


// putIfAbsent 不存在键时,才添加
map.putIfAbsent ("小米", 1000);
System.out.println (map);

// 获取键对应的值,不存在 返回null
Integer huawei = map.get ("华为");
System.out.println ("华为价格:" + huawei);
Integer huaweiS = map.get ("华为s");
System.out.println ("华为s价格:" + huaweiS);

// 获取键对应的值,不存在 返回默认值
Integer huaweiS2 = map.getOrDefault ("华为s", 9999);
System.out.println ("华为s价格:" + huaweiS2);

System.out.println ("=========================");
/**
 * 获取 键值对集合 来遍历map
 */
Set<Map.Entry<String, Integer>> entries = map.entrySet ();
for (Map.Entry<String, Integer> entry : entries) {
    String key = entry.getKey ();
    Integer value = entry.getValue ();
    System.out.println (key + " " + value);
}
System.out.println ("=========================");
/**
 * 获取所有的键
 */

Set<String> keySet = map.keySet ();
for (String key : keySet) {
    Integer val = map.get (key);
    System.out.println (key + " " + val);
}
System.out.println ("=========================");


/**
 *  Lambda表达式 遍历map
 */
map.forEach ((k, v) -> {
    System.out.println (k + " " + v);
});
System.out.println ("=========================");

// 删除键值对,返回值是 键对应的值
Integer val = map.remove ("小米");
System.out.println (val);
System.out.println (map);
System.out.println ("=========================");
// 判断键是否存在
boolean keyHua = map.containsKey ("华为");
boolean keyXm = map.containsKey ("小米");
System.out.println ("华为:" + keyHua + " " + "小米:" + keyXm);
System.out.println ("=========================");
// 判断值是否存在
boolean containsValue = map.containsValue (1000);
System.out.println ("值是否存在:" + containsValue);
System.out.println ("=========================");
// 判断是否为空
boolean empty = map.isEmpty ();
System.out.println ("map为空:" + empty);
System.out.println ("=========================");

// 集合大小
int size = map.size ();
System.out.println ("集合大小:" + size);
System.out.println ("=========================");
// 清空集合
map.clear ();

字符串

equals（）

String s1="abc"; // 字符串池
// 字符串对象
String s2=new String ("aBc");
System.out.println (s1==s2); // 比较地址值  false
System.out.println (s1.equals (s2)); // 比较字符串内容 false
System.out.println (s1.equalsIgnoreCase (s2)); // 比较字符串内容，忽略大小写 true
	

charAt() 、toCharArray() 、length()

 Scanner scanner = new Scanner (System.in);

 System.out.println ("请输入字符串：");
 String s = scanner.nextLine ();
 /*for (int i = 0; i < s.length (); i++) {

     System.out.print (s.charAt (i) + " ");
 }*/
 char[] chars = s.toCharArray ();
 for (char aChar : chars) {
     System.out.print (aChar+" ");
 }

substring()

String s = "abcdefg";
String substring = s.substring (1, 4);  // len = 4 -1 = 3,返回值才是截取后的结果
System.out.println (substring); // bcd

// 手机号中间四位屏蔽
String s = "15155644987";
// 截取前三位
String s1 = s.substring (0, 3);
// 截取后四位
String s2 = s.substring (7, 11);
// String s2 = s.substring (7);
String res = s1 + "****" + s2;
System.out.println (res);

trim() 返回 去除前后空格的新字符串 — O(n)

indexOf(String str)

返回str第一个出现的位置(int)，没找到 则返回-1。 — O(m * n) m为原串长度， n为str长度

(假如要找一个字符char c，str可以表示成 String.valueOf© ,然后作为参数传进去.

s.indexOf(String str, int fromIndex); // 同上，但从fromIndex开始找 — O(m * n)

lastIndexOf(String str);

返回str最后出现的位置(int)，没找到则返回-1。 — O(m * n) m为原串长度， n为str长度
(假如要找一个字符char c，str可以表示成String.valueOf©,然后作为参数传进去.

lastIndexOf(String str, int fromIndex); // 同上，
但从fromIndex开始从后往前找 [0 <- fromIndex] — O(m * n)

replace()

// 手机号中间四位屏蔽
String talk = "你玩的真好，他妈不要再玩了，TMD,SB,给我去死，傻逼东西";

// 定义敏感词库
String[] dicts = {"TMD", "SB", "MLGB", "你妈", "傻逼", "去死", "他妈"};

for (String dict : dicts) {
	// 替换后 赋给原字符串
    talk = talk.replace (dict, "***");
}
System.out.println (talk);

split() 、 toLowerCase() 、toUpperCase()

split(String regex);    // 返回 String[]，以regex(正则表达式)分隔好的字符换数组。 ---- O(n)

// For example
// 从非"/"算起 若"/a/c" -> 会变成"" "a" "c"
String[] date = str.split("/");     // date[0]:1995 date[1]:12 date[2]:18 --- O(n)

s = s.toLowerCase();    // 返回一个新的字符串全部转成小写 --- O(n)
s = s.toUpperCase();    // 返回一个新的字符串全部转成大写 --- O(n)

字符串拼接 StringBuilder

字符串 拼接

字符串 反转

StringBuilder sb = new StringBuilder ("abc");
sb.append (1);
sb.append (2.3);
sb.append (true);
System.out.println (sb.toString ());
StringBuilder reverse = sb.reverse ();
int length = sb.length ();
System.out.println (length); // 字符串长度
// 字符串反转
System.out.println (reverse.toString ());

数学

Math 类

        // abs  求绝对值
        System.out.println (Math.abs (-2));
        System.out.println (Math.abs (2));
        // ceil   往 数轴的正方向进一,参数是double类型的，返回值是double类型的
        System.out.println (Math.ceil (3.14)); // 4
        System.out.println (Math.ceil (3.99)); // 4
        System.out.println (Math.ceil (-3.14)); // -3
        System.out.println (Math.ceil (-3.99)); // -3
        // floor  往 数轴的负方向进一，参数是double类型的，返回值是double类型的
        System.out.println (Math.floor (-3.14)); // -4
        System.out.println (Math.floor (-3.99)); // -4
        System.out.println (Math.floor (3.99)); // 3
        System.out.println (Math.floor (3.14)); // 3

        // max  求最大值,参数可以是int、double、float、long等
        System.out.println (Math.max (1, 2)); // 2
        System.out.println (Math.max (2, 1)); // 2
        System.out.println (Math.max (2, 5)); // 5

        // min  求最小值,参数可以是int、double、float、long等
        System.out.println (Math.min (1, 2)); // 1
        System.out.println (Math.min (2, 1)); // 1
        System.out.println (Math.min (2, 5)); // 2
        // pow  求幂, 第一个参数是底数, 第二个参数是指数,参数类型是double类型的
        // 结果是一个double类型的数
        System.out.println (Math.pow (2, 3)); // 8
        System.out.println (Math.pow (2, 4)); // 16
        System.out.println (Math.pow (2, 5)); // 32
        // round  四舍五入,参数是double类型的,返回值是long类型的
        System.out.println (Math.round (3.14)); // 3
        System.out.println (Math.round (3.5)); // 4
        System.out.println (Math.round (3.99)); // 4
        System.out.println (Math.round (-3.14)); // -3

Integer

     // 将字符串转换为int
     Integer integer = Integer.valueOf ("123");
     System.out.println (integer);
     // 求int的最大值
     int maxValue = Integer.MAX_VALUE;
     System.out.println (maxValue);
     // 求int的最小值
     int minValue = Integer.MIN_VALUE;
     System.out.println (minValue);
     // 将字符串转换为int ----->Integer.parseInt
     int i = Integer.parseInt ("4500");
     System.out.println (i);