数组方法笔记

String 常用的排序，找最大最小，反转，交换，合并，查找，删除等方法。

数组：

排序

使用**sort();**方法给数组进行排序

int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
      Arrays.sort(array);
//再使用循环将数组遍历显示就能得到
//[length: 10] -9, -7, -3, -2, 0, 2, 4, 5, 6, 8

String方法

方法名	描述
public char charAt(int index)	根据下标获取字符
public boolean contains(String str)	判断当前字符串中是否包含str
public char[] toCharArray()	将字符串转换成数组。
public int indexOf(String str)	查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
public int length()	返回字符串的长度
public String trim(）	去掉字符串前后的空格
public String toUpperCase()	将小写转成大写
public boolean endsWith(String str)	判断字符串是否以str结尾
public String replace(char oldChar,char newChar)	将旧字符串替换成新字符串
public String[] split(String str)	根据str做拆分
public String subString(int beginIndex,int endIndex)	在字符串中截取出一个子字符串

使用binarySearch() 方法来查找数组中的元素；

int index = Arrays.binarySearch(array, 2);
System.out.println("元素 2  在第 " + index + " 个位置");

array.leng;获取数组长度。

数组的反转

     ArrayList arrayList = new ArrayList();
        for(int i=0;i<10;i++){
   		 arrayList.add(i);
   					 }
    System.out.println("反转前排序: " + arrayList);
    Collections.reverse(arrayList);
    System.out.println("反转后排序: " + arrayList);
//反转前排序: [A, B, C, D, E] 
//反转后排序: [E, D, C, B, A] 

查找数组中的最大最小值

    Integer[] numbers = { 8, 2, 7, 1, 4, 9, 5};
      int min = (int) Collections.min(Arrays.asList(numbers));
      int max = (int) Collections.max(Arrays.asList(numbers));
      System.out.println("最小值: " + min);
      System.out.println("最大值: " + max);

合并数组

通过 List 类的 Arrays.toString () 方法和 List 类的

list.Addall(array1.asList(array2) 方法将两个数组合并为一个数组：

	String a[] = { "A", "E", "I" };
    String b[] = { "O", "U" };
      List list = new ArrayList(Arrays.asList(a));//创建数组初始值为a数组
      list.addAll(Arrays.asList(b));//将b数组添加到list数组后
      Object[] c = list.toArray();//转换为string类型输出
      System.out.println(Arrays.toString(c));

数组的填充:

int array[] = new int[7];
Arrays.fill(array, 100);//参数为（数组名字，数组的值）
for (int i=0, n=array.length; i < n; i++) {
    System.out.println(array[i]);
}
System.out.println();
Arrays.fill(array, 2, 7, 21);
//参数为（改变参数的数组的下标位置，数组的受影响最大下标，数值填充的值）
for (int i=0, n=array.length; i< n; i++) {
    System.out.println(array[i]);
}

数组的查找

int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
	Arrays.sort(array);//从小大到排列
System.out.println(Arrays.toString(array));
	int index = Arrays.binarySearch(array, 2);寻找值为2的值，返回其下标
System.out.println("Found 2 @ " + index);

删除数组

ArrayList objArray = new ArrayList();
      objArray.clear();
      objArray.add(0,"第 0 个元素");
      objArray.add(1,"第 1 个元素");
      objArray.add(2,"第 2 个元素");
      System.out.println("数组删除元素前："+objArray);
      objArray.remove(1);
      objArray.remove("0th element");
      System.out.println("数组删除元素后："+objArray);
   }

//输出
//数组删除元素前：[第 0 个元素, 第 1 个元素, 第 2 个元素]
//数组删除元素后：[第 0 个元素, 第 2 个元素]

数组的交集：

 ArrayList objArray = new ArrayList();
      ArrayList objArray2 = new ArrayList();
      objArray2.add(0,"common1");
      objArray2.add(1,"common2");
      objArray2.add(2,"notcommon");
      objArray2.add(3,"notcommon1");
      objArray.add(0,"common1");
      objArray.add(1,"common2");
      objArray.add(2,"notcommon2");
      System.out.println("array1 数组元素："+objArray);
      System.out.println("array2 数组元素："+objArray2);
      objArray.retainAll(objArray2);

数组交集：

ArrayList objArray = new ArrayList();
ArrayList objArray2 = new ArrayList();
objArray2.add(0,"1");
objArray2.add(1,"2");

objArray2.add(2,"3");
objArray2.add(3,"4");

objArray.add(0,"1");
objArray.add(1,"2");

objArray.add(2,"5");

System.out.println("array1 数组元素："+objArray);
System.out.println("array2 数组元素："+objArray2);
objArray.retainAll(objArray2);
//打印出两组交集的值
System.out.println("array2 & array1 数组交集为："+objArray);
/**
输出
array1 数组元素：[1, 2, 5]
array2 数组元素：[1, 2, 3, 4]
array2 & array1 数组交集为：[1, 2]
*/

判断两数组是否相等

int[] ary =  {1,2,3,4,5,6};
int[] ary1 = {1,2,3,4,5,6};
int[] ary2 = {1,2,3,4};
Arrays.equals(ary, ary1)；
//输出true
Arrays.equals(ary, ary2)；
//输出false

---

自己写的小方法

寻找数组中的最大最小值

 int num=0;
 int [] a={1,2,3,4,5,5,5,2,3,4,6,3};
// Arrays.sort(a);
 for(int i=0;i<a.length;i++){
    num= Math.max(num,a[i]);
 }
 System.out.println("最大值为"+num);

排序

int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
Arrays.sort(array);

查找数组中的重复的值与次数

  int[] array = {1, 2, 5, 5,8,7, 6, 6, 7, 2, 9, 2};
    Map<Integer,Integer> map = findRepetition(array);
    if(map!=null){
        for (Map.Entry<Integer,Integer> entry : map.entrySet()){
            if(entry.getValue()>1){
                System.out.println("数字 "+entry.getKey()+" 重复出现"+entry.getValue()+"次");
            }else{
                System.out.println("数字 "+entry.getKey()+" 只出现1次 无重复");
            }
        }
    }
}

private static Map<Integer, Integer> findRepetition(int[] arr){
    Map<Integer, Integer> map = new HashMap<>();
    if(arr == null || arr.length <= 0){
        return null;
    }
    for(int i = 0; i < arr.length; i ++){
        if(map.containsKey(arr[i])){
            map.put(arr[i], map.get(arr[i])+1);
        }else{
            map.put(arr[i], 1);
        }
    }
    return map;
}

交换指定字符串

replace

String b="abcdrfg";
String d=b.replace("abc","ddd");
//交换指定字符
System.out.println(b);
System.out.println(d);

Java Math floor、ceil、rint 及 round 用法

floor 返回不大于的最大整数。

round 则是 4 舍 5 入的计算，入的时候是到大于它的整数。

round 表示"四舍五入"，算法为Math.floor(x+0.5) ，

即将原来的数字加上 0.5 后再向下取整，所以 Math.round(11.5) 的结果为 12，

Math.round(-11.5) 的结果为 -11。

Math.floor 向下取整，即小于这个数的最大的那个整数。

Math.ceil向上去取整

Math.rint返回最接近这个值的整数

Math.round四舍五入

abs返回绝对值