牛客笔试题没有头绪？你需要的是扎实的基础

计算机存储单元

• 计算机最小i信息单元：位（bit），又称为“比特位”，通常用小写字母“b”表示。
• 计算机最小存储单元：字节（byte），通常用大写字母“B”表示。
• 1B（字节）= 8bit
• 1KB = 1024B
• 1MB = 1024KB
• 1GB = 1024MB
• 1TB = 1024GB

Java数据类型有哪些？

Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型分配不同的存储空间，相应的数据大小也不一样。
Java数据类型分为8种基本数据类型和3种引用数据类型，基本数据类型又分为数值类型和非数值类型。数值类型包括：byte，short，int（整数）；float，double（浮点数）；char（字符）；非数值类型包括：boolean（布尔）。引用类型包括：类（class），接口（interface），数组（[]）。

• byte，1字节，取值范围为 -128~127。
• short，2字节，取值范围为 -32768~32767。
• int（默认），4字节，取值-2^31 到2^31-1
• long，8字节，取值-2^63到 2^63-1
• float（默认），4字节，取值
• double，8字节
• char，2字节
• boolean，1字节，true/false

数组如何使用？

• 数组声明

int[] arr;//声明数组，告诉计算机我要存储一组整数（推荐）或int arr[];

• 数组初始化

arr = new int[5];//0
//静态初始化:我们赋值，系统分配长度（arr2.length）
int[] arr2 = {11,22,33};

• 数组赋值（修改值）

arr[2]=33;

• 数组遍历

double[] myList = {1.9, 2.9, 3.4, 3.5};
for (int i = 0; i < myList.length; i++) {
   System.out.println(myList[i] + " ");
}
for (double element: myList) {
   System.out.println(element);
}

• 数组排序

//冒泡排序
int[] arr = {34,1,78,9,43};
int temp;
for(int i = 0 ; i < arr.length-1;i++) {//轮
    for(int j = 0; j < arr.length-1-i; j++) {//次
        if(arr[j] > arr[j+1]) {
            temp = arr[j];
            arr[j]= arr[j + 1];
            arr[j + 1] = temp;
         }
     }
}
for(int n: arr) {
   System.out.println(n);
}
//选择排序
int [] arr = {5,12,3,78,345};
int temp;
for(int i = 0; i < arr.length-1; i++) {//位置
   for(int j = i + 1; j < arr.length; j++) {
      if(arr[i] > arr[j]) {
         temp = arr[i];
         arr[i] = arr[j];
         arr[j] = temp;
      }
   }
}
for(int n:arr) {
   System.out.println(n);
}

• 数组元素位置查找

//普通查询：循环数组，比较元素，获取下标
//二分查找
public static int searchArray(int[] arr,int key) {
  int max,min,mid;
  min = 0;
  max = arr.length-1;
  mid = (min+max)>>1;
  while(arr[mid]!=key) {
   if(key > arr[mid]) {
    min = mid + 1;
   }else{
    max = mid - 1;
   }
   //判断元素是否存在。
   if(max>1;
  }
  return mid;
 }
}

• 数组复制

//Arrays 类的 copyOf() 方法 
int[] newScores = (int[])Arrays.copyOf(scores,8);
//Arrays 类的 copyOfRange() 方法 
int newScores[] = (int[]) Arrays.copyOfRange(scores, 0, 5);
//System 类的 arraycopy() 方法
System.arraycopy(scores, 0, newScores, 2, 8);
//Object 类的 clone() 方法
int newScores[] = (int[]) scores.clone();

字符串常见操作

• 字符串查找

 - indexOf（String s） 返回参数字符串s在指定字符串中首次出现的索引位置 ，没有则返回-1
 - lastIndexOf(String str)  返回字符串最后一次出现的索引位置，没有则返回-1

• 获取指定索引位置字符

使用charAt()方法可将指定索引处的字符返回。

• 获取子串

 - substring(int beginIndex)：该方法返回的是从指定的索引位置开始截取知道该字符串结尾的子串。
2.substring(int beginIndex,  int endIndex)：beginIndex : 开始截取子字符串的索引位置，endIndex：子字符串在整个字符串中的结束位置

• 去除空格

trim()方法返回字符串的副本，忽略前导空格和尾部空格

• 字符串替换

replace(”oldChar“,”newChar“)：方法可实现将指定的字符或字符串替换成新的字符或字符串

• 判断字符串的开始与结尾

1.startsWith(String prefix) ：该方法用于判断当前字符串对象的前缀是否是参数指定的字符串。
2.endsWith(String suffix) ：该方法用于判断当前字符串是否以给定的子字符串结束

• 判断字符串是否相等

1.equals(String otherstr)：如果两个字符串具有相同的字符和长度，则使用equals()方法比较时，返回true。同时equals()方法比较时区分大小写。
2.equalsIgnoreCase(String otherstr)： equalsIgnoreCase()方法与equals()类型，不过在比较时忽略了大小写。

• 按字典顺序比较两个字符串

//比较字符unicode值，str位于otherstr之前返回负整数，之后返回整数，相等则返回0
 str.compareTo(String otherstr);

• 字母大小转换

str.toLowerCase();   //所有字符转小写
str.toUpperCase();   //所有字符转大写

• 字符串分割

str.split(String sign);  //按指定的分隔字符或字符串对内容进行分割，并存于字符串数组中
str.split(String sign, in limit)； //根据给定的分割符对字符串进行拆分，并限定拆分的次数。

Arrays类常见用法

• 数组排序

//void Array.sort(Object[] array)
int[] nums = {2,5,0,4,6,-10};
Arrays.sort(nums); //升序
for(int i :nums)
    System.out.print(i+" ");
}
//Arrays.sort(Object[] array, int from, int to)
int[] nums = {2,5,0,4,1,-10};
Arrays.sort(nums, 0, 4);
for(int i :nums)
   System.out.print(i+" ");
}

• 数组填充值

//Arrays.fill(Object[] array,Object object)
int[] nums = {2,5,0,4,1,-10};
Arrays.fill(nums, 1);
for(int i :nums)
    System.out.print(i+" ");
}
//Arrays.fill(Object[] array,int from,int to,Object object)
int[] nums = {2,5,0,4,1,-10};
//对数组元素下标2到4的元素赋值为3
Arrays.fill(nums,2,5,3);
for(int i :nums)
    System.out.print(i+" ");
}

• 数组字符串形式

int[] nums = {2,5,0,4,1,-10};
System.out.println(Arrays.toString(nums));//[2, 5, 0, 4, 1, -10]

• 多维数组字符串形式

//Arrays.deepToString(Object[][] arrays)
int[][] nums = {{1,2},{3,4}};
System.out.println(Arrays.deepToString(nums));//[[1, 2], [3, 4]]

• 数组转列表

String[] card = {"3","4", "5","6", "7", "8", "9", "10", "J", "Q", "K", "A", "2", "joker", "JOKER" };
List<String> cards = Arrays.asList(card);

• 数组复制

int newScores[] = (int[]) Arrays.copyOfRange(scores, 0, 5);
int[] newScores = (int[])Arrays.copyOf(scores,8);

• 判断两个数组是否相等

boolean isOk = Arrays.equals(Object[] a, Object[] a2)

Collectionis类常见用法

• 对列表排序

//列表中的所有元素都必须实现 Comparable接口。
//此列表内的所有元素都必须是使用指定比较器可相互比较的
final List<Map.Entry<String, Integer>> mapList = new ArrayList<Map.Entry<String, Integer>>(result.entrySet());
//通过比较器实现比较排序
Collections.sort(mapList, new Comparator<Map.Entry<String, Integer>>() {
	public int compare(Map.Entry<String, Integer> mapping1, Map.Entry<String, Integer> mapping2) {
			return mapping2.getValue().compareTo(mapping1.getValue());
	}
});
//compareTo等同于
public static int compare(int x, int y) {
   return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

• 混排（Shuffling）

//打乱排序
Collections.Shuffling(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.shuffle(list);
for (int i = 0; i < array.length; i++) {
  System.out.println(li.get(i));
}

• 反转(Reverse)

//使用Reverse方法可以根据元素的自然顺序 对指定列表按下标降序进行排序。
Collections.reverse(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
   list.add(new Double(array[i]));
}
Collections. reverse (list);
for (int i = 0; i < array.length; i++) {
  System.out.println(li.get(i));
}
//231,456,23,111,112

• 元素替换

使用指定元素替换指定列表中的所有元素。
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j<str.length;j++){
	li.add(new String(str[j]));
}
Collections.fill(li,"aaa");
for (int i = 0; i < li.size(); i++) {
	System.out.println("list[" + i + "]=" + li.get(i));
}
//aaa,aaa,aaa,aaa,aaa

• 列表拷贝

double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {1131,333};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j<arr.length;j++){
li.add(new Double(arr[j]));
}
Collections.copy(list,li); //(源列表，目标列表)
for (int i = 0; i <list.size(); i++) {
System.out.println("list[" + i + "]=" + list.get(i));
}

• 最小元素：Collections.min(list);
• 最大元素：Collections.max(list);
• 返回指定源列表中最后一次出现指定目标列表的起始位置

Int locations = Collections.lastIndexOfSubList(list,li);

• 返回指定源列表中第一次出现指定目标列表的起始位置

Int locations = Collections.indexOfSubList(list,li);

• 根据指定的距离循环移动指定列表中的元素

Collections.rotate(list,-1); //向前移一位

Scanner类的常见用法

java.util.Scanner 是 Java5 的新特征，用于从键盘输入内容，读取到程序当中。

• 输入对象

// System.in代表标准输入，就是键盘输入
Scanner sc = new Scanner(System.in);

• next()方法

一定要读取到有效字符后才可以结束输入。
对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。

• nextLine()方法

以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
可以获得空白。

• hasNext()方法

输出为布尔值。
判断输入的缓存中是否有效字符，遇到空格结束。
如果只输入空格，不会匹配，返回false。
hasNext(“patter”)  //模式匹配

• hasNextLine()方法

以Enter为结束符,判断此行有没有输入，空白输入也会返回true；

• 注意事项

通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，
在读取前我们一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据：
hasNext() —> next()
hasNextLine()----> nextLine()

• nextInt()方法：获取整数
• nextFloat()方法：获取浮点数