《day18_String练习_基本类型包装类_集合入门》

package cn.itcast.api.String.test;

public class StringTest_1 {

    public static void main(String[] args) {

        String s1 = "asdfitcastghijfghjk";
        String s2 = "xcitcastvbnm";

        String maxSubStirng = getMaxSubstring(s2, s1);
        System.out.println("maxSubString:" + maxSubStirng);
        /*
         * 作业1：获取两个字符串的最大相同子串。 "asdfitcastghijfghjk" "xcitcastvbnm"
         * 
         * 思路： 1，先明确两个字符串的长短，在长串中判断短串是否存在。 2，存在，已找到，说明短串就是最大的相同。
         * 不存在，就将短串按照长度递减的方式，获取短串中的子串，并到长串中判断。 3，一旦存在，便结束查找。
         */

    }

    private static String getMaxSubstring(String s1, String s2) {
        String max, min;
        // 明确哪个是长串，哪个是短串。
        max = (s1.length() > s2.length()) ? s1 : s2;
        min = max.equals(s1) ? s2 : s1;

        // 验证max和min.
        /*
         * System.out.println("max:"+max); System.out.println("min:"+min);
         */

        for (int i = 0; i < min.length(); i++) {
            for (int start = 0, end = min.length() - i; end < min.length(); start++, end++) {
                    String temp = min.substring(start,end);
                    if(max.contains(temp)){
                        return temp;
                    }
            }
        }
        return null;
    }

}

package cn.itcast.api.String.test;

import java.util.Arrays;

public class StringTest_2 {

    public static void main(String[] args) {
        String str = "cfdasbv";
        str = sortStringByChars(str);
        System.out.println("str="+str);

    }
    /*
     * 
     * 作业2：对字符串中字符进行自然顺序排序。
     * cfdasbv--->abcdfsv
     * 
     * 思路：
     * 1，排序都是对数组排序。
     * 2，数组中的元素都是在字符串中，把字符串转成数组。
     * 3，对数组排序。
     * 4，将排序后的数组转成字符串。
     */

    public static String sortStringByChars(String str) {
        //1，将字符串转成数组。转成字符数组。
        char[] chs = getArray(str);
        //2,对数组排序。
        sort(chs);
        //3，将排序后的数组转成字符串。返回。
        return new String(chs);
    }

    private static void sort(char[] chs) {
        Arrays.sort(chs);
        
    }

    /**
     * 将字符串转成字符数组。
     * @param str
     * @return
     */
    private static char[] getArray(String str) {
        // TODO Auto-generated method stub
        return str.toCharArray();
    }

}

package cn.itcast.api.String.test;

public class StringTest_3 {
    public static void main(String[] args){
        String str = "   it  cast    ";
//        String s1 = str.trim();
        String s1 = myTrim(str);
        System.out.println("-"+s1+"-");
    }

    /**
     * 模拟trim功能。
     * 
     */
    public static String myTrim(String str){
            
        //定义两个变量，一个记录头，一个记录尾。
        int start = 0;
        int end  =str.length()-1;
        
        //2,获取头部非空白的位置，
        while(start<=end && str.charAt(start)==' '){
            start++;
        }
        //2,获取尾部非空白的位置，
        while(start<=end && str.charAt(end)==' '){
            end--;
        }
        
        //截取字符串。
        return str.substring(start, end+1);
    }
}

package cn.itcast.api.wrapper.demo;

public class WrapperDemo {

    public static void main(String[] args) {
        /*
         * 场景：通过文本框获取用户输入的数字数据，可是得到的都是字符串。
         * 如果想要对字符串中的数字进行运算，必须要将字符串转成数字。
         * JAVA提供了相应的解决对象。
         * 基本数据类型对象包装类：Java将基本数据类型值封装成对象。
         * 封装成对象有什么好处？因为可以提供更多的操作基本数值的方法。
         * 
         * byte     Byte
         * short    Short
         * int         Integer
         * long        Long
         * float    Float
         * double    Double
         * boolean    Boolean
         * char        Character
         */
        
        //学习一下整数Integer
        /*
         * 基本类型对象包装类特点：
         * 1，用于在基本数据类型和字符串之间进行转换。
         * int parseInt(String);
         * byte parseByte(String);
         * boolean parseBoolean(String);
         * 
         * xxx parseXxx(String);
         * 只有Character没哟解析方法。
         * 
         * 
         */
        
        /*System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.toBinaryString(10));
        System.out.println(Integer.toBinaryString(-6));*/
        
        //1,字符串--->基本数值。结果：基本数值（字符串）演示Integer  int(String)
        
        System.out.println(Integer.parseInt("123")+2);//NumberFormaExctpioon
        System.out.println(Integer.parseInt("2222", 10));//按照指定的进制进行转换。
        
        //2,基本数值转成字符串。34+""  String.valueOf(34)Integer.toString(int);
        System.out.println(34+5);
        
        //3,基本数值---》包装对象。
        Integer i = new Integer(4);
        Integer ii = Integer.valueOf("4");
        
        //包装对象---》基本数据类型
        int num = i.intValue();
        System.out.println(num);
    }

}

package cn.itcast.api.wrapper.demo;

public class WrapperDemo2 {

    public static void main(String[] args) {
        
//        int i = 4;
//        Integer i = new Integer(4);
//        JDK1.5以后，有了一个包装类的新特性。目的简化书写。自动装箱
        Integer i = 4;//自动装箱。Integer.valueOf(4);
        i = i+5;//原理是：等号右边将i对象转成基本数值。i.intValue()+5;加法运算后，在此装箱。
        //i = Integer.valueOf(i.inValue()+5);
        System.out.println(i);
        
        Integer a = new Integer(3);
        Integer b = new Integer(3);
        System.out.println(a==b);
        System.out.println(a.equals(b));
        
        System.out.println("===============");
        Integer x = 127;
        Integer y = 127;
        System.out.println(x==y);
        System.out.println(x.equals(y));

    }

}

//WrapperTest.java
package cn.itcast.api.wrapper.demo;

import java.util.Arrays;

public class WrapperTest {

    public static void main(String[] args) {
        /*
         * 练习：面试题：
         * "23 9 -4 18 100 7";
         * 要求对这串数字按照从大到小排序，生成一个数值有序的字符串。
         */
        String numString = "23 9 -4 18 100 7";
        numString = sortNumberString(numString);
        System.out.println("nums="+numString);

    }

    public static String sortNumberString(String numString) {
        //1一个字符串通过分割变成多个字符串。split();
        String[] strs = numString.split(" ");
        
        //2,不能直接对字符串大小排序。因为字符串23比字符串9要小。必须转成整数值。
        //将字符串数组转成int[] 数组。
        int[] nums = parseIntArray(strs);
        
        //3,对数组排序。
        Arrays.sort(nums);
        
//        4，将数组转成字符串。
        return toString(nums);
    }
    private static String toString(int[] nums) {
        StringBuilder sb  = new StringBuilder();
        for (int i = 0; i < nums.length; i++) {
            if(i!=nums.length-1){
                sb.append(nums[i]+" ");
            }else{
                sb.append(nums[i]);
            }
        }
        return sb.toString();
    }

    //将字符串数组转成int[] 数组
    public static int[] parseIntArray(String[] strs) {
        //定义一个int数组。
        int[] arr = new int[strs.length];
        
        //2，遍历字符串数组。把元素转成int存储到int数组中。
        for (int i = 0; i < strs.length; i++) {
            arr[i] = Integer.parseInt(strs[i]);
        }
        return arr;
    }

}