Java入门2

一、Arrays工具类

1.数组地址的比较

int [] arr1={1,2,3,4,5};
int [] arr2={1,2,3,4,5};
System.out.println(arr1==arr2);//结果是false因为其比较的是地址数组不能用==判断
int [] arr1={1,2,3,4,5};
int [] arr2=arr1;
System.out.println(arr1==arr2);//结果是true因为arr1把地址赋给arr2

2.Arrays.equals(arr1,arr2);

接受两个数组，返回两个数据是否相等。比较的原理是，逐一比较两个数组的每一个值，是否相等。而如果使用==，是比较两个数组名中存储的地址，是否相等。

int [] arr1={1,2,3,4,5};
int [] arr2={1,2,3,4,5};
System.out.println(Arrays.equals(arr1, arr2));

3.Arrays.sort();

对数组进行升序排列，会直接修改原数组的内容。

int []a={1,5,6,2,3,10,8};
Arrays.sort(a);
System.out.println(Arrays.toString(a));

4.Arrays.sort();

对数组的指定区域进行排序，左闭右开区间，包含起始下标，不含下标。

int []a={1,5,6,2,3,6,10,8};
Arrays.sort(a,3,6);
System.out.println(Arrays.toString(a));

5.Arrays.toString();

将数组转成字符串，转换之后的格式[1,2,3,4]。

6.Arrays.fill(a, 12);

将数组的每一项，都赋值给指定的数值。

int []a=new int[10];
Arrays.fill(a, 12);
System.out.println(Arrays.toString(a));

7.int []b=Arrays.copyOf(a, 10);

将a[]的指定个数，copy到一个新的数组；如果个数>a.length则新数组中多余的位置默认值补齐，如果个数＜a.length则copy原数组的前半部分。

int a[]={1,2,3,4,5,6,7,8,9};
int []b=Arrays.copyOf(a, 5);
System.out.println(Arrays.toString(b));

8.Arrays.binarySearch(a,1);

查找数组中的指定元素，如果找到返回下标，否则返回负数，使用这个方法，必须是有序的数组，可以用Arrays.sort()进行排序。

int []a={0,2,2,3,4,5,6};
Arrays.sort(a);
System.out.println(Arrays.binarySearch(a,1));//相当于二分法需要排序后使用

9.二维数组的声明

 int a[ ][ ] = new int[2][ ];

a[0] = new int[3]; 

a[1] = new int[5];

int [][]a={{1},
               {1,2},
        {1,2,3},
        {1,2,3}};
    for(int i=0;i<a.length;i++){//a.length=====>>>>a[i]
        for(int j=0;j<a[i].length;j++)
                    {//a[i].length======>>>>a[i][j]
            System.out.print(a[i][j]+"\t");//不用Arrays.toString
        }
        System.out.println();
}                                

二、String类

1.String类声明

/**
* [String类]位于java.lang包，java.lang是Java的语言包，使用时无须导包，自动导入，无import
 * 2.拿到一个字符串对象
 * （1）字面量声明String s="Hello World";
 * （2）new关键字声明 String s1=new String("Hello World");
 */
        String s="Hello World";
        String s2=new String();
        String s1=new String("Hello World");
        System.err.println(s1);//err.红色的

2.String类的length()方法（字符串的长度）

/**
 * s.length()返回字符串的长度，.length（）是一个方法，使用时不能掉（）
 */
        System.out.println("请输入用户名：");
        Scanner in=new Scanner(System.in);
        String s=in.next();
        if(s.length()<6){//带括号的是方法，不带括号的是属性
        System.out.println("用户名最小为6位");
        }

3.String类的equals()方法

    /**
         * 字符串不是引用数据类型
         * s1.equals(s2)判断字符串是否相等
         *
         * .equals()的比对原理，是判断两个字符串的为一个字符是否相等。
         * ==的比对原理，是判断两个字符串中存储的地址是否相等。
         */
        String s1="123";
        String s2="123";
        String s3=new String("123");
        String s4=new String("123");
        System.out.println(s1==s2);//比地址
        System.out.println(s1==s3);
        System.out.println(s1==s4);
        System.out.println(s2==s3);
        System.out.println(s2==s4);
        System.out.println(s4==s3);
        System.out.println(s1.equals(s4));//比较内容
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s2.equals(s3));
        System.out.println(s2.equals(s4));
        System.out.println(s3.equals(s4));
        String s6=s1;//s1不会变
         s6="456";
        System.out.println(s1);
        String s5=s3;//s3不会变
         s6="456";
        System.out.println(s3);

4.String类的equalsIgnoreCase()方法（忽略大小写的比较）

                /**
         * s.equalsIgnoreCase(s1)忽略大小写比对
         */
        String s="JH";
        String s1="jh";
        System.out.println(s.equals(s1));
        System.out.println(s.equalsIgnoreCase(s1));
                //忽略大小写比对JH=jh        

5.String类的toLowerCase()和toUpperCase()方法（将字符串转成大小写）

                /**
         * s.toLowerCase()将所有字符转换成小写
         * s.toUpperCase()将所有字符转换成大写
         */
        String s="JH";
        String s1="jh";
        System.out.println(s.equals(s1));
        System.out.println(s.equalsIgnoreCase(s1));
                //忽略大小写比对JH=jh
        System.out.println(s.toLowerCase());
        System.out.println(s.toUpperCase());
        System.out.println(s.toLowerCase().equals(s1));

6.String类字符串的连接

                /**
         * 1.使用+
         * 2.String s1=s.concat(s2);连接，将s1和s2连接，将s2连接到s1的后面，返回一个新字符串
         */

        String s="哈哈";
        String s1=s.concat("真帅");
        System.out.println(s1);

7.String类的IndexOf()方法

/**
         * .indexOf()在字符串中查找指定的字符或子串，并返回其下标，否则返回-1；
         * 可以接受字符串，字符，整数类型的参数，如果传入整数，将根据ASXII码自动转为字符（A-65,a-97）
         *
         *
         * .lastIndexOf()在字符串中查找指定的字符或子串最后一次出现的位置，并返回其下标，否则返回-1
         */
        String s="abcdefffg";
        System.out.println(s.indexOf("cde"));//
        System.out.println(s.indexOf("cdf"));//-1不连续
        System.out.println(s.indexOf(100));//a的阿斯科码值为97，3的为100
        System.out.println(s.lastIndexOf("cdf"));
        System.out.println(s.lastIndexOf("f"));

8.String类的substring()方法

        /**
         * substring()截取字符串的指定位置，返回一个新的子串
         * （1）传入一个参数，表示起始下标，将从此下标开始，一直截到字符串以后
         * （2）传入两个参数，表示起始下标和结束下标，为左闭右开，包含起始不含结尾
         */

        String s="abcdefg";
        System.out.println(s.substring(3));
        System.out.println(s.substring(3,5));//左闭右开

9.String类的trim()方法

    /**
         *.trim()去掉字符串两端的空格
         */
        String s="      abcdefg      ";
        System.out.println(s);
        System.out.println(s.trim());

10.String类的replace()方法

/**
* replace将字符串中的指定区域，用新的字符串替换掉
*/
String s="abcdefg";
System.out.println(s.replace("abc","niu"));

11.String类的split()方法

/**
     * .split()传入指定字符，将字符串分割为多个子串，返回一个字符串类型的数组；
     * 如果传入一个空字符串，则将原字符的每一个字符进行分割
     *
     * .split( , )第二个参数，可以传入一个整数，表示将当前字符串分为几部分
     * 如果传入的整数，小于原来分割的总部分，则剩余的
     */

        String s="haha haha haha";
        String [] a=s.split(" ");
        System.out.println(Arrays.toString(a));

        String []b=s.split("h", 3);
        System.out.println(Arrays.toString(b));

12.String类的charAt()方法

/**
         * charAT();用法
         * 

         * /
                int j=0;
        Scanner in=new Scanner(System.in);
        String n=in.next();
        char a=in.next().charAt(0);
        for(int i=0;i<n.length();i++){
            if(n.charAt(i)==a){
                j++;
            }
        }
    System.out.println(j);
         

三、StringBuffer类

1.StringBufferl类的声明

        /**
         * StringBuffer声明
         * [StringBuffer类]
         * 1.[StringBuffer是String的增强版，位于java.lang包中]
         * 2.StringBuffer与String的最大区别在于：StringBuffer是可变可追加的
         * 而String一旦声明不可改变，不能插入；
         */
        StringBuffer sb=new StringBuffer("hahah");

2.StringBuffer类的toString()方法

/**
         * .toString:将StringBuffer类型转换成String类，但在输出时，可以不用转换，
        *将自动进行转换
         */
        String s=sb.toString();
                System.out.println(sb);

3.StringBuffer类的append()方法

/**
                 * .append()在原字符串的最后追加新的字符
                 * 原字符串会被直接改变，同时还会将追加之后的字符串返回
                 * append可以接受各种类型的参数，会自动转成字符串后追加到原字符串后
                 */
                StringBuffer sb1=sb.append("呵呵呵");
                System.out.println(sb);
                System.out.println(sb1);

                char []a={'a','b','c','d'};
                StringBuffer sb2=sb.append(a,1,2);//(a,b,c)b是起始下标，c是几个
                System.out.println(sb2);

4.StringBuffer类的删除方法

/**
         * delete();传入两个下标,表示删除了这两个下标的字符，左闭右开区间
         *
         * .deletCharAt（）传入一个下标，删除一个指定位置的字符
         */

        StringBuffer sb=new StringBuffer("帅不帅你说了不算");//左闭右开区间
        StringBuffer s =sb.delete(0, 2);
        System.out.println(s);

        StringBuffer s1 =sb.deleteCharAt(2);
        System.out.println(sb);
        System.out.println(s1);

5.StringBuffer类的insert()插入方法

/**
         * 在原字符串的指定下标位置，插入新的子串
         * 新的字符串可以是任何数据类型,
         */
        StringBuffer sb=new StringBuffer("帅不帅你说了不算");//左闭右开区间
        StringBuffer s=sb.insert(3, "可能");
        System.out.println(sb);
        System.out.println(s);

四、面向对象

1.面向对象的解释以及使用类和对象的步骤

/**
         * 面向对象&面向过程
         * 0.面向机器语言：汇编语言。
         * 1.面向过程：
         *         面向过程专注于如何解决一个问题的过程。
         *         编程特点：出现了一个个的函数，由一个个函数实现解决问题的一系列步骤。
         * 2.面向对象：
         *         面向对象专注于有谁（哪个）来解决问题，而调用者无需关注对象实现的细节。
         *         编程特点：出现了一个个类，从类中拿到对象，通过对象直接解决问题。
         * Java  php  C++  C# Python
         *
         *
         * [类&对象]
         * 1.类：具有一系列相同属性（特征）和方法（行为）的个体的集合，称为类。
         *         类是一个抽象的概念，只能说类具有哪些属性，不能直接对属性进行赋值。
         *         例如：人类由身高的属性，但是不能说人类的身高是180。
         * 2.对象：从类中拿出具有具体属性值的个体，称为对象。
         *         对象是从类中哪出的一个具体的个体，需要对属性进行具体的赋值。
         *         例如：人类由身高的属性，那么说张三是人类中的一个个体，张三的身高是180，张三是人类中的一个对象。
         * 3.类和对象的关系：
         *         类是对象的抽象化（类有属性，但不能给类的属性赋值），对象是类的具体化。
         *         类是对象的描述，对象是类的个体（对象是类的实例）。
         *         程序中由类产生对象。
         * 4.面向对象的三个特征：继承，封装，多态。
         *         判断编程是不是面向对象，就要看符不符合继承，封装，多态。（js不能实现多态）
         *         从类中new出一个对象，类的实例化。
         *
         *
         * [使用类和对象的步骤]
         *1.声明一个类：
         *        public class Person(){
         *            public String name;//属性
         *            public void say(){}//方法
         *}
         * 2.使用对象名.属性名或对象名.方法名,调用类中的属性和方法。
         *         p.say();//调用方法
         *        System.out.println(p.name);//调用属性
         */

        String s=new String("哈哈哈");
        //对象的实例化通过new关键字拿到一个类的对象，使用对象名.方法名，可以调用类中已经声明的方法
        Person p=new Person("张三", 5);

        p.say();
        System.out.println(p.name);

2.方法的返回值

如果方法有返回值，可以使用return返回结果；

如果方法没有返回值，需要设置返回值为void，而且方法中必须没有return；

有返回值的方法，调用时不一定必须接收返回值；

没有返回值的方法，调用时一定不能接收返回值；

public void sya(){
     (无返回值)
}
public People say(int num.String name ){
return null;(有返回值)
}

3.方法的调用

    /* *
         * [方法的调用]
         * 1.声明的方法，只有在调用的时候才能执行方法中的代码
         * 2.方法的调用：
         * 在本类的其他方法中调用：使用方法名（）；或者使用this.方法名（）；
         * public void eat(){
         *    say();
         *   //    this.say();
         * }
         *
         * 调用其他类的方法：首先应该实例化拿到对象，在通过对象名调用方法
         * JCMethod1 dm=new  JCMethod1();
         *   //        int num=dm.say();
         *   //        System.out.println(num);
         *   //        dm.eat();
         *           dm.eat();
         */

4.方法的参数

(1).声明方法时，也可以在（）设置调用方法时需要传入的参数列表，多个参数之间用逗号隔开；
public void eat(String food,int i)
声明方法时的参数列表，称为形参列表；
(2).调用方法时，必须按照形参列表的要求，一一传入对应的参数；
dm.eat("鸡蛋灌饼",12);
调用方法时的参数列表，成为实参列表；

5.成员变量&局部变量

(1).成员变量：写在方法体外，直接在类中生命的属性，称为成员变量。
　　成员变量的作用范围：在整个类中使用。
(2).局部变量：在方法体里面声明的变量叫局部变量。
　　局部变量只在当前方法中有效，方法的形参列表，都属于局部变量。
(3).成员变量和局部变量的区别：
　　（1）作用于不同。
　　（2）初始值不同，java中成员变量默认初始值，局部变量没有默认初始值。
　　（3）优先级不同，就近原则,当成员变量和局部变量重名时，在方法中优先使用局部变量。
 　　如果需要使用成员变量，需要使用this.进行使用。

public String name="zhangsan";//成员变量
public void eat(String food,int i){
String name;//局部变量
System.out.println("我叫"+this.name);
}

6.类的定义

（类名要用public修饰）声明一个类：
*[访问控制符]class 类名{}
*public class Person{}
*注意类名的命名规范

7.声明一个属性

/**
 *  声明一个属性，[访问控制符]属性类型  属性名
 */
    public String name;
    public int age;

8.构造函数

/**
     * 构造函数：是类中的一个特殊方法
     * 1.构造函数与类同名
     * 2.构造函数没有返回值，连void都没有
     *
     * 如果没有手动写构造函数，则系统会默认提供一个空参构造；
     * 如果手动写构造函数，则系统不再提供空参构造。
     *
     * 构造函数无需我们手动调用，而是在实例化对象时，自动调用构造函数
     * 构造函数的作用：在实例化对象的时候，给类的属性赋默认值
     */
    public Person(String name,int age){
        //使用this.属性表示使用本类的属性
        this.name="默认名称";//name参数，this.name
        this.age=0;
        System.out.println("调用构造函数");
    }

9.声明方法

/**
     * 声明一个方法，[访问控制符]  返回值类型  方法名（）{}
     *
     * 如果没有返回值，用void代替
     */
    public void say(){
        System.out.println("我是人类，我会说话。");
        System.out.println(this.name+this.age);

    }