排列 二分查找 字符串 方法

• 排列

int nums[] = new int[]{72,72,72,72,89,65,58,87,91,53,82,71,93,76,68};
        Integer[] integer_nums = new Integer[] {72,72,72,72,89,65,58,87,91,53,82,71,93,76,68};
        //sort和parallelSort相比,大型数据的话parallelSort会相对快一些
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));
        //实现降序排列
        //需要实现Comparator方法
        Arrays.sort(integer_nums, new Comparator<Integer>(){
            public int compare(Integer a , Integer b) {
                return b - a;
            }
        });
        System.out.println(Arrays.toString(integer_nums));
        

• 二分查找

//binarySearch返回查找元素的下标
        //找不到返回的是-1
        //13
        int index = Arrays.binarySearch(nums, 91);
        System.out.println(index);
        
        //copyOf方法,截取数组中的一部分(前 n 个)
        //[53, 58, 65, 68, 71]
        int[] new_nums = Arrays.copyOf(nums, 5);
        System.out.println(Arrays.toString(new_nums));
        

• 字符串

 

 

JAVA的基本数据类型为什么不包括String?

字符串内部其实就是一个使用final关键字定义的char[]数组，数组长度一旦声明则不可改变，字符串一旦声明则不可改变，改变的引用内存指向。

String属于一个类，不属于一个关键字、准确的说它不是一个数据类型。只是由于它字符串的特殊支持，我们习惯把它叫做字符串类型。

 

 

1. copyOf
2. copyOfRange
3. 字符串定义
4. 字符串拼接
5. 任意类型和字符串拼接的结果都是字符串
6. 字符串长度
7. indexOf
8. lastIndexOf
9. charAt
10. 异常
11. 截取字符串substring
12. 返回字符数组toCharArray
13. split
14. replace
15. 字符串比较(有new 就是不相等,因为是新的地址空间)
16. 字符串拼接(StringBuffer&&StringBuilder)
17. arraycopy
18. final 修饰的字符串
19. 对字符串的修改都不会改变原串
20. 字符数组转字符串

//copyOf方法,截取数组中的一部分(前 n 个)
        //[53, 58, 65, 68, 71]
        int[] new_nums = Arrays.copyOf(nums, 5);
        System.out.println(Arrays.toString(new_nums));

//copyOfRange方法,返回数组中从a-b的部分
        //[65, 68, 71, 72, 72]
        new_nums = Arrays.copyOfRange(nums, 2, 7);
        System.out.println(Arrays.toString(new_nums));
        

//字符串定义
        String str = "java so easy";
        str = new String("java so easy");
        //1.字符串不是基本数据类型
        //2.String不是关键字
        //3.String在java.lang包下

//字符串拼接
        String str1 = "Hello";
        String str2 = "World";
        System.out.println(str1 + str2);//HelloWorld
        

//任意类型和字符串拼接的结果都是字符串
        //+号的优先级一样
        str = 12 + 23 + "结果";//35结果
        str = "结果" + 12 + 23;//结果1223
        

//字符串长度
        System.out.println(str.length());//6
        //注意:是方法,而不是和数组呢些的一样是一个属性
        

//indexOf方法查找子串出现位置的下标,如果找不到返回-1
        str = "1234567894";
        System.out.println(str.indexOf("3"));//2
        System.out.println(str.indexOf("0"));//-1 表示没找到
        System.out.println(str.indexOf("456"));//3 (找子串)
        

//返回最后一次出现的下标
        index = str.lastIndexOf("4");
        System.out.println(index);
        //9
        

//charAt返回下标为n的字符
        char c = str.charAt(2);
        System.out.println(c);
        //3

//异常
        //char c = str.charAt(11);
        //StringIndexOutOfBoundsException
        
        //int nu = 12/0;
        //System.out.println(nu);
        //ArithmeticException
        

//截取字符串
        str = "123456789";
        System.out.println(str.substring(1));
        //23456789
        System.out.println(str.substring(1 , 4));
        //234

    //返回字符数组
        System.out.println(str.toCharArray());
        //123456789

//split是切割字符串的,选择的字符会被切掉
        String[] arr = str.split("6");
        System.out.println(Arrays.toString(arr));
        //[12345, 789]

String str3 = "11111111";
        String[] arr3 = str3.split("1");
        System.out.println(Arrays.toString(arr3));
        //[]

//replace把一部分替换成另一个
        System.out.println(str.replace("123", "0"));
        //0456789

 

//字符串比较
        //结论: 有new 就是不相等,因为是新的地址空间
        
        String str1 = "1234";
        String str2 = "1234";
        
        String str3 = new String("1234");
        String str4 = new String("1234");
        
        String str5 = "12" + "34";
        String str6 = "1" + "234";
        
        String str7 = "12" + new String("34");
        String str8 = "1" + new String("234");
        
        System.out.println(str1 == str2);//true
        
        System.out.println(str1 == str3);//false
        System.out.println(str3 == str4);//false
        
        System.out.println(str1 == str6);//true
        System.out.println(str5 == str6);//true
        
        /**************************************/
        System.out.println(str1 == str7);//false
        System.out.println(str1 == str8);//false
        System.out.println(str7 == str8);//false
        
        //比较字符串的值是否一样
        //equals
        boolean bool = str1.equals(str3);
        System.out.println(bool);
        //true

 final修饰的字符串

 String hw = "hello world";

    String hello = "hello";
    final String finalWorld2 = "hello";
    final String finalWorld3 = hello;
    final String finalWorld4 = "he" + "llo";

    String hw1 = hello + " world";
    String hw2 = finalWorld2 + " world";
    String hw3 = finalWorld3 + " world";
    String hw4 = finalWorld4 + " world";

    System.out.println(hw == hw1);//false
    System.out.println(hw == hw2);//true
    System.out.println(hw == hw3);//false
    System.out.println(hw == hw4);//true

为什么是这个结果呢?有关参考:https://blog.csdn.net/linbilin_/article/details/51840089 

 http://www.mamicode.com/info-detail-2370655.html

//字符数组转字符串
String s = "abcdefg";
char[] cs = s.toCharArray();
return new String(cs);

 

equal源码:

 

 

 

/**
         * 这种方法会产生很多的中间变量,例如拼接这个数组
         * 会产生1234,123456等等中间变量
         * 当数组中元素有几万个的时候,则会产生好多好多好多中间变量捏
         * 故因此有了StringBuffer,StringBuilder
         * */
        String[] str_arr = {"12","34","56","78"};
        String str = "";
        for(int i = 0 ; i < str_arr[i].length() ; i++) {
            str += str_arr[i];
        }

 

//StringBuffer(线程安全 慢)&&StringBuilder
        //采用append方法追加
        /**
         * StringBuffer就是我们用一个Buffer把所有的要追加的字符串存入一个数组中
 5          * 当这个数组空间不够的时候就进行扩容
 6          * 扩容刚开始Buffer默认长度是16
 7          * 扩容就是当发现我们空间不够的时候
 8          * 刚开始这个Sb,Sf不太大的时候,乘2就可以很大的扩容
 9          * 扩容的源码是int newCapacity = (value.length << 1) + 2;
10          * 如果传入的值是0,左移操作结果还是0,出于安全性考虑给他最后+2
11          * 如果这个还不够的话,那么你需要多大我就给你多大
12          * 最后把这个数组调用toString方法转化成字符串
13          */
        str_arr = new String[]{"12","34","56","78"};
        StringBuffer stringBuffer = new StringBuffer();
        for(int i = 0 ; i < str_arr.length ; i++) {
            stringBuffer.append(str_arr[i]);
        }
        System.out.println(stringBuffer.toString());
        

 

 

 

• 引用类型的默认值

//所有引用类型的默认值都是null
//char 是\u0000 是一个UniCode码,是一个不可显字符,还是空
//null也是一个值,是一个空间,这个空间里什么都没有

        //arraycopy(原数组,原数组起始位置,目标数组,目标数组起始位置,复制多大) 
        //数组扩容 
        //不是真正的扩容,是将原数组的内容放到更大的数组中 
        int[] arr= {1,2,3,4,5,6,7,8,9};
        int[] new_arr = new int[20];
        System.arraycopy(arr, 0, new_arr, 3, arr.length);
        System.out.println(Arrays.toString(new_arr));

 

 

• 方法

//方法
        //声明一个方法,接收一个整数
        //返回一个长度为该整数的整数类型数组
        int[] nums = shuzu(Math.random()*20);
        System.out.println(Arrays.toString(nums));

public static int[] shuzu(double number) {
        
        if(number < 0)
            return null;
        int[] nums = new int[(int)number];
        return nums;
    }

 

 

 

作业:

//声明一个方法,接受一个数组(整数),返回这个数组中的最大值
//声明一个方法,接收两个字符串,返回小串是否是大串的子串
//声明一个方法,接受一个字符串,返回这个字符串的所有子串
//判断一个正整数是不是回文数
    public static void main(String[] args) {
        int[] arr= {1,2,3,4,5,6,7,8,9};
        System.out.println(MaxNum(arr));
        
        String str1 = "123456789";
        String str2 = "234";
        System.out.println(StringCompare(str1, str2));
        
        System.out.println(Arrays.toString(isSubString(str1)));
        
        int[] nums = new int[]{1,2,3,3,2,1};
        System.out.println(HuiWen(nums));
        
    }
    
    public static int MaxNum(int[] nums) {
        int max = nums[0];
        for(int i = 0 ; i < nums.length ; i++) {
            max = max > nums[i] ? max : nums[i];
        }
        return max;
    }
    
    public static boolean StringCompare(String str1 , String str2) {
        if(str1.indexOf(str2) == -1)
            return false;
        else
            return true;
    }
    
    public static String[] isSubString(String str) {
        String[] value = str.split("");
        String[] strings = new String[(value.length + value.length * value.length) / 2];
        int count = 0;
        for(int i = 1 ; i <= value.length ; i++) {//截取长度为i的子串
            for(int j = 0 ; j <= value.length - i; j++) {//长度为i的子串共有j = n - i个
                String tempString = "";
                for(int k = j ; k < i + j ; k++) {//找到长度为k的子串
                    tempString += value[k];
                }
                strings[count++] = tempString;
            }
        }    
        return strings;
    }
    
    public static boolean HuiWen(int[] nums) {
        if(nums.length == 0) return false;
        else if(nums.length == 1) return true;
        else {
            int half_length = nums.length / 2;
            for(int i = 0 , j = nums.length - 1 ; i < half_length ; i++ , j--) {
                if(nums[i] != nums[j]) {
                    return false;
                }
            }
        }
        return true;
    }
}