1 Arrays

PS：Arrays位于java.util包下

1 int binarySearch(type[] a, type key);

使用二分法查询 key 元素在 a 数组中的索引，如果数组不包含这个值，则返回负数。使用前要求这个数组是升序排列，才能得到正确结果。

1 int binarySearch(type[] a, int fromIndex, int toIndex, type key);

和上面类似，但是只从 fromIndex 到 toIndex 范围内找元素，一样要求数组是升序的。

1 type[] copyOf(type[] originla , int length);

复制一个数组，length 是新数组的长度。如果 length 小于原数组，则只复制前length长度的值；如果大于原数组，后面补0、false、null。

1 type[] copyOf(type[] originla , int from, int to);

与前面类似，但是只复制规定范围内的元素。

1 boolean equals(type[] a1 , type[] a2)

如果 a1 和 a2 长度相等且元素相同，则返回 true，否则返回false。

1 void fill(type[] a , type val)

该方法会把 a 数组的所有元素都赋值为val的值。

1 void fill(type[] , int fromIndex , int toIndex, type val)

与上方法类似，规定了范围。

1 void sort(type[] a)

该方法对 a 数组的元素进行升序排列。特别的是，如果 a 是字符串数组，则按照字符串长度的升序排列。

1 void sort(type[] a , int fromIndex int toIndex)

类似，仅对范围内排序。

1 String toString(type[] a)

将一个数组转换成一个字符串，该方法按顺序把多个数组元素连成一个字符串，用逗号和空格分隔每个元素，外面用 '[' 、']'括起来。

2 Java 8 之后 Arrays 增强功能

下面方法中，parallel 代表可以用多 cpu 提高性能，xxx 或 Xxx 代表数据类型，比如int，double

1 void parallelPrefix(xxx[] array, XxxBinaryOperator op)
2 void parallelPrefix(xxx[] array , int fromIndex , toIndex , XxxBinaryOperator op)

该方法使用 op 参数指定的计算公式计算得到的结果作为新的数组元素。op 计算公式包括 left 、 right 两个形参，其中 left 代表新数组中钱一个前一个索引处的元素，right 代表 array 数组中当前索引处的元素。新数组的第一个元素无须计算，直接等于 array数组的第一个元素。

1 void setAll(xxx[] array , IntToXxxFunction generator)

该方法用指定的生成器为所有数组元素设置值，该生成器控制数组元素的值的生成算法。

1 void parallelSetAll(xxx[] array , IntToXxxFunction generator)

与上方法类似，增加了并行能力，利用多 cpu 提升性能

1 void parallelSort (xxx[] a)
2 void parallelSort (xxx[] a ， int fromIndex , int toIndex)

与之前Arrays里面的sort方法类似，增加了并行能力，可以利用多 cpu 提高性能。

增强功能的程序示例：

 1 import java.util.Arrays;
 2 import java.util.function.IntBinaryOperator;
 3 import java.util.function.IntUnaryOperator;
 4 public class ArraysTest {
 5     public static void main(String[] args) {
 6         int[] array1 = new int[] {3, -4, 25, 16, 30, 18};
 7         //用Arrays类的方法排序
 8         Arrays.parallelSort(array1);
 9         System.out.println(Arrays.toString(array1));
10         int[] array2 = new int[] {3, -4, 25, 16, 30, 18};
11         //前一个索引的元素乘以当前元素得到新数组,需要import java.util.function.IntBinaryOperator
12         Arrays.parallelPrefix(array2, new IntBinaryOperator() {
13             public int applyAsInt(int left , int right) {
14                 return left * right;
15             }
16         });
17         System.out.println(Arrays.toString(array2));
18         int array3[] = new int[5];
19         //使用当前索引*5的方法生成元素，需要import java.util.function.IntUnaryOperator
20         Arrays.parallelSetAll(array3, new IntUnaryOperator() {
21              //operand 是当前索引
22             public int applyAsInt(int operand) {
23                 return operand * 5;
24             }
25         });
26         System.out.println(Arrays.toString(array3));
27     }
28 }

输出结果：

3 二维数组

3.1 二维数组原理

因为数组元素可以是引用类型，所以可以让数组作为数组的元素，这样就产生了二维数组。java 中二维数组不要求是矩阵形式。

3.2 定义二维数组

1 type[][] arrayName;

其实质还是一维数组，只是数组的元素也是引用。

3.3 初始化

1 arrayName = new type[length][]

这里相当于定义了 length 个type[]类型的变量。接下来继续初始化

1 arrayName[0] = new type[2]

这里把一个长度为2的数组赋给前面定义的一维数组的第一个元素，此时arrayName[0][0]和arrayName[0][1]的值都是0（如果type是 int 的时候），一维数组的其它元素都是null；

一个初始化好的二维数组在内存中的示意图：

3.4 常用初始化方法

同时定义二维数组的两个维数（矩形数组）

1 int[][] arrayName = new int[3][4]

显示定义（静态）二维数组（不一定是矩形）

1 int [][] a = {{1,2},{3,4,0,9},{5,6,7}};
2 或者
3 String[][] str1 = new String[][]{new String[3] , new String[]{"Hello"}}
4 简化版
5 String[][] str2 = {new String[3] , new String[]{"Hello"}};

4 LeetCode 练习

13.罗马数字转整数

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如，罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

解题思路：

遵循一个逻辑，如果某个字符代表的值大于等于它的下一个字符代表的值，则是“加”；如果小于它的下一个字符代表的值，则是“减”。注意最后一个字符没有“下一个”，一定是加。

源码：

 1 class Solution {
 2     public int romanToInt(String s) {
 3         char[] ch = s.toCharArray();
 4         int result = 0;
 5         for(int i = 0; i < ch.length; i++){
 6             if(i == ch.length - 1){
 7                 result += getNum(ch[i]);
 8             }else if (getNum(ch[i]) >= getNum(ch[i+1])){
 9                 result += getNum(ch[i]);
10             }else{
11                 result -= getNum(ch[i]);
12             }
13         }
14         return result;
15     }
16
17     public static int getNum(char tmp){
18         switch(tmp){
19             case 'M':
20                 return 1000;
21             case 'D':
22                 return 500;
23             case 'C':
24                 return 100;
25             case 'L':
26                 return 50;
27             case 'X':
28                 return 10;
29             case 'V':
30                 return 5;
31             case 'I':
32                 return 1;
33         }
34         return 0;
35     }
36 }

14. 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

源码：

 1 class Solution {
 2     public String longestCommonPrefix(String[] strs) {
 3         String commonPrefix = "";
 4         int length = ~0>>>1;
 5         if(strs.length == 0)
 6             return commonPrefix;
 7         for (int i = 0; i < strs.length; i++){
 8             if(strs[i].length() < length)
 9                 length = strs[i].length();
10         }//求出最短字符长度
11         /*可用这种方法求最短长度
12     Arrays.sort(strs);//按长度排列
13 int len=Math.min(strs[0].length(),strs[strs.length-1].length());
14         */
15         HashMap<Integer , Character> map = new HashMap<Integer , Character>();
16         for(int i = 0; i < strs[0].length();i++){
17             map.put(i , strs[0].charAt(i));
18         }//将第一个字符串每个字符加入hashmap
19         outer:
20         for(int i =0; i < length; i++){
21             for(int j = 0; j < strs.length; j++){
22                 if(map.get(i) == strs[j].charAt(i)){}
23                 else{
24                     break outer;
25                 }//如果和该位置字符不匹配则退出循环
26             }//每完成一次循环将该位置字符加到结果上
27             commonPrefix += strs[0].charAt(i);
28         }
29         return commonPrefix;
30     }
31 }

转载于:https://www.cnblogs.com/carlosouyang/p/10731916.html

Arrays工具、二维数组以及LeetCode练习题相关推荐

c语言通过本地文档输入二维数组，leetcode c本地调试时使用
在Leetcode刷题的时候,有时候会想在本地调试来定位错误,但是在本地生成测试用例非常麻烦,特别是对于一些大型二维数组的时候,于是我根据Leetcode二维数组的输入输入格式,写了一个自动生成int ...
android arrays.xml 二维数组,android中怎的从xml文件中解析一个二维数组
Java codeXmlPullParser parser = Xml.newPullParser(); try { int nTouched = 0; String result = null; / ...
NumPy二维数组-行向量、列向量
1D arrays 在二维数组中被当作行向量,所以在矩阵乘中 (n,) 与 (1, n) 的结果是相同的. 1D arrays 经过转置是不能得到列向量的,即 (n,).T => (n,1) 不 ...
Arrays工具类和二维数组
一.数组的更多内容 1.1 Arrays工具类 JDK提供的java.util.Arrays工具类,包含了常用的数组操作,方便我们日常开发.Arrays类包含了:排序.查找.填充.打印内容等常见的操作 ...
【java进阶06：数组】使用一维数组模拟栈数据结构使用二维数组模拟酒店，酒店管理系统 Arrays工具类冒泡排序算法、选择排序算法、二分法
目录数组二维数组总结作业 Arrays工具类数组数组总结及静态初始化一维数组 /* Array:1.java语言中的数组是一种引用数据类型,不属于基本数据类型,数组的父类是Object ...
剑指offer刷题(java)|二维数组中的查找|替换空格|leetcode刷题
文章目录前言一.二维数组中的查找题目题解一题解二题解三二.替换空格题目题解一题解二题解三前言本文主要是写了我做算法题的思路以及对其他优秀题解的自我理解. 一.二维数组中的查找 ...
二维数组 Arrays
二维数组数组分类按照数据类型分按照维度分数组是按照里面存储的数据类型来确定类型数组中可以存储任意类型的数据(基本数据类型.引用数据类型String) 数组就是引用数据类型数组中存储的数据就 ...
Java_数组（声明、创建、初始化、复制、增强型for循环、二维数组、排序、Arrays类）
Java_数组数组的基本概念声明数组创建数组初始化数组方法一:分配空间与赋值分步进行方法二:分配空间,同时赋值增强型for循环复制数组二维数组排序 Arrays类 copyOfRa ...
arrays中copyof复制两个数组_数组，及二维数组
1.1 命令行参数(C) 在程序运行过程中,可以向应用程序传递一些参数,这些参数称为命名行参数. public 命令行参数以字符串的形式传入args数组中.可以一次传递0-多个参数,以空格分割. 如果 ...

Arrays工具、二维数组以及LeetCode练习题