public class HelloWorld {    
	public static void main(String []args) {        
	System.out.println("Hello World");    
}}

package com.hgd.study2;

import java.util.Scanner;

/**
 * java的流程控制：顺序结构 分之机构 循环结构
 * 
 * @author HuTiger 顺序结构：通过debug模式可以看出java程序的运行时顺序结构的
 * 
 *         分支结构：if语句
 *
 */
public class ProcessControl {

    public static void main(String[] args) {
        // IfStudy();
        // SwitchCaseStudy();
        // WhileStudy();
    }

    /*
     * IF语句
     */
    private static void IfStudy() {

        /*
         * 根据条件表达的世界(true||false)来判断是否进入语句块 if(条件表达式){ 语句块 } 继续执行后面的语句
         */
        int i = 100;
        if (i > 60) {
            System.out.println(i);
        }
        System.out.println("后面需要执行的语句");

        /*
         * if else 语句
         */

        // system.in就是标准输入，可以获取从键盘输入的值
        // 通过scanner(jdk提供给我们的工具)来处理获取到的数据
        System.out.println("请输入分数!");
        Scanner sc = new Scanner(System.in);

        int j = sc.nextInt();// 把用户输入的数赋值给j
        System.out.println("控制台获取到的值是：" + j);

        if (j > 60) {
            System.out.println("通过");
        } else {
            System.out.println("没通过");
        }
        System.out.println("当if else 执行后需要执行的内容");

        /*
         * if else if else if ...else
         */
        // 场景：将一个5(score)分制分为 :5分的评价等级A 4==B 3==C 其他是D
        Scanner sca = new Scanner(System.in);
        int score = sca.nextInt();
        if (score >= 0 && score <= 5) {
            if (score == 5) {
                System.out.println("A");
            } else if (score == 4) {
                System.out.println("B");
            } else if (score == 3) {
                System.out.println("C");
            } else {
                System.out.println("D");
            }
        } else {
            System.out.println("输入不合法");
        }

        /*
         * 练习：百分制系统 90-100 优秀 75-89 良好 60-74 合格 其他 不合格
         */
        Scanner scan = new Scanner(System.in);
        int score1 = scan.nextInt();
        if (score1 >= 0 && score1 <= 100) {
            if (score1 >= 90 && score1 <= 100) {
                System.out.println("优秀");
            } else if (score1 >= 75) {
                System.out.println("良好");
            } else if (score1 >= 60) {
                System.out.println("合格");
            } else {
                System.out.println("不合格");
            }
        } else {
            System.out.println("输入不合法");
        }

    }

    /*
     * switch case
     */
    private static void SwitchCaseStudy() {

        /*
         * 分支语句：switch case key：需要比较的表达式 value：与表达式进行比较的值
         * 执行流程：如果key和value比较的结果为true，那么将执行case部分的代码，case部分可以有多个 类似于else if 部分
         * 区别是key和value之间的比较只能是== default部分是不满足以上任何去执行的代码 ，类似于else
         * 
         * switch 后面括号中的表达式的值必须是符合byte，char，short，int类型的常量表达式 jdk1.7以后可以使用string
         * ，而不能用浮点型或long类型
         * 
         * switch(key) { case value: break; default: break; }
         */

        // 场景：将一个5(score)分制分为 :5分的评价等级A 4==B 3==C 其他是D
        Scanner sc = new Scanner(System.in);
        int score = sc.nextInt();
        switch (score) {
        case 5:
            System.out.println("A");
            break;// 标准写法 break不能少 跳出当前语句块，如果没有break会直接进入下一个case语句
        case 4:
            System.out.println("B");
            break;
        case 3:
            System.out.println("C");
            break;
        default:
            System.out.println("D");
            break;
        }
    }

    /*
     * while 循环和do while
     */
    private static void WhileStudy() {

        /*
         * 执行流程： 当条件表达式为true的时候进入代码块，执行需要执行的代码 当条件表达式为false的时候执行后面的语句
         * 
         * while(条件表达式){ 需要执行的代码部分 } 后面的语句
         */

        /*
         * 场景：输入1-100的整数分析：给输出的值一个变量I，当i在1-100之间的时候输出
         */
        int i = 1;// 循环的起点
        while (i <= 100) {
            System.out.println(i);
            // 给出循环的步长
            i++;
        }
        System.out.println("打印结束");
        
        
        /*
         * do while
         * 
         * do{
         * }while(条件表达式)
         */
        
        int a=1;
        do{//语句块中的内容无论条件是否满足都会先执行一次
            System.out.println(a);
            a++;
        }
        while(a<=0);
        
    }

    /*
     * for循环
     */
    private static void ForStudy() {

        /*
         * 场景：打印1-100 int i=1是循环的起点 i++ 循环的补偿 i<=100 循环的条件
         */
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
        }
        System.out.println("打印结束");
    }
}

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
 
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

package object;

/
 * 成员变量和局部变量
 * 
 * */
public class VariableTest {
    
    //成员变量
    public static String staticname = "类属性";
    public String nostaticname = "实例属性";
    
    //没有初始化的成员变量
    public static String staticname1;
    public String nostaticname1;
    
    //定义一个方法
    public void info(){
        //在方法中定义一个局部变量i
        //int i;
        //直接输出是输出不出来的，因为没有初始化
        //System.out.println(i);
        //定义一个局部变量i并初始化
        int i = 10;
        //输出i
        System.out.println(i);
    }
    
    //定义了一个静态的方法
    public static void infos(){
        int i = 20;
        System.out.println(i);
    }
    
    public static void main(String[] args) {
        /*第一问：类属性和实例属性的范围一样吗？*/
        //在没创建实例之前 可以调用类属性,但不能调用实例属性
        System.out.println(VariableTest.staticname);//结果：类属性
        //实例化对象之后,就可以调用实例属性了
        VariableTest vt = new VariableTest();
        System.out.println(vt.nostaticname);//结果：实例属性
        /*--- 结论：在成员变量中，类属性的范围比实例属性大一点 ---*/
        
        System.out.println("----------");
        
        /*第二问：成员变量需要显性初始化吗？*/
        //直接调用没有初始化的类属性
        System.out.println(VariableTest.staticname1);//结果：null
        //用实例化对象调用没有初始化的实例属性
        System.out.println(vt.nostaticname1);//结果：null
        /*--- 结论：成员变量会自动隐性初始化，赋给变量一个默认值  ---*/
        
        System.out.println("----------");
        
        /*第三问：如果用实例化后的对象去调用类属性会怎么样？*/
        //vt.staticname; 
        //这样会报错
        //Syntax error, insert "VariableDeclarators" to complete LocalVariableDeclaration
        //翻译：语法错误,插入“变量声明符”来完成局部变量声明
        /*为什么会报错。一开始我以为是因为eclipse出错了
         *后来我直接用文本文档重写了一个test
         *编译文件后，报不是语句的错，然后我又试了一下
         *VariableTest.staticname
         *也是报错，说明这种写法是不正确的，具体为什么有待研究*/
        vt.staticname = "改变了的类属性";
        //如果同时给类属性赋值，就不会报错...有警告
        //The static field Variable Test.static name should be accessed in a static way
        //翻译：静态字段变量测试。静态的名字应该在一个静态方法访问
        System.out.println(vt.staticname);//结果：改变了的类属性
        //这样就不会报错，但是会有警告，同上↑
        /*结论：用实例化后的对象调用类属性，格式正确的情况下，是可以调用的，但有警告
         *通过对象调用类属性，同样可以改变类属性的值*/
        
        System.out.println("----------");
        
        //定义在方法中的局部变量
        /*第四问：定义在方法中的局部变量，出了方法还能访问吗？*/
        //调用方法
        vt.info();//结果：10
        //现在还能用info中的i吗？
        //System.out.println(i);
        //报错：i cannot be resolved to a variable
        //翻译：i 不能转换成一个变量
        /*结论：定义在方法中的局部变量，出了方法就不能被访问了*/
        
        System.out.println("----------");
        
        //定义在代码块中的局部变量
        /*第五问：定义在代码块中的局部变量，出了代码块还能访问吗？*/
        {
            int j = 11;
            System.out.println(j);//结果：11
        }
        //出了代码块
        //System.out.println(j);
        //同样报错，内容与上面的一样
        /*定义在代码块中的局部变量，出了代码块就不能访问了*/
        
        System.out.println("----------");
        
        //后续：一个静态方法
        infos();//结果：20
        //这样依然报错
        //System.out.println(i);
        
    }
}

package object;

/
 * 局部变量覆盖成员变量
 * */
public class VariableCover {
    
    /*当实例变量与方法中的局部变量同名时，
     *局部变量的值会覆盖实例变量*/
    //定义实例变量
    public String city = "合肥";
    private static String citys = "滁州";
    //定义一个方法
    public void function(){
        String city = "蚌埠";
        //输出
        //方法中的同名局部变量会覆盖实例变量
        System.out.println(city);//结果：蚌埠
        //要想调用实例变量，可以用this
        System.out.println(this.city);//结果：合肥
    }
    
    public static void main(String[] args) {
        String citys = "南京";
        //方法中的同名局部变量会覆盖实例变量
        System.out.println(citys);//结果：南京
        //可以通过类名调用被覆盖的类属性
        System.out.println(VariableCover.citys);//结果：滁州
        
        String city = "上海";
        System.out.println(city);//结果：上海
        //这样也可以
        System.out.println(new VariableCover().city);//结果：合肥
        new VariableCover().function();
    }
}

abstract class Absdemo{    
	abstract void show();
}
		class Outer{
			...
		public void function(){
			new Absdemo()//这是一个Absdemo的一个匿名子类对象
							{
			void show(){
				System.out.println("匿名内部类！")；
						}
					}.show();
				}
...
}

package com.javacodegeeks.advanced.objects;

public class Person {
    private final String firstName;
    private final String lastName;
    private final String email;
    
    public Person( final String firstName, final String lastName, final String email ) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }
    
    public String getEmail() {
        return email;
    }
    
    public String getFirstName() {
        return firstName;
    }
    
    public String getLastName() {
        return lastName;
    }

    // Step 0: Please add the @Override annotation, it will ensure that your
    // intention is to change the default implementation.
    @Override
    public boolean equals( Object obj ) {
        // Step 1: Check if the 'obj' is null
        if ( obj == null ) {
            return false;
        }
        
        // Step 2: Check if the 'obj' is pointing to the this instance
        if ( this == obj ) {
            return true;
        }
        
        // Step 3: Check classes equality. Note of caution here: please do not use the 
        // 'instanceof' operator unless class is declared as final. It may cause 
        // an issues within class hierarchies.
        if ( getClass() != obj.getClass() ) {
            return false;
        }
        
        // Step 4: Check individual fields equality
        final Person other = (Person) obj;
        if ( email == null ) {
            if ( other.email != null ) {
                return false;
            } 
        } else if( !email.equals( other.email ) ) {
            return false;
        }
        
        if ( firstName == null ) {
            if ( other.firstName != null ) {
                return false;
            } 
        } else if ( !firstName.equals( other.firstName ) ) {
            return false;
        }
            
        if ( lastName == null ) {
            if ( other.lastName != null ) {
                return false;
            }
        } else if ( !lastName.equals( other.lastName ) ) {
            return false;
        }
        
        return true;
    }        
}

// Please add the @Override annotation, it will ensure that your
// intention is to change the default implementation.
@Override
public int hashCode() {
    final int prime = 31;
        
    int result = 1;
    result = prime * result + ( ( email == null ) ? 0 : email.hashCode() );
    result = prime * result + ( ( firstName == null ) ? 0 : firstName.hashCode() );
    result = prime * result + ( ( lastName == null ) ? 0 : lastName.hashCode() );
        
    return result;
}      

// Please add the @Override annotation, it will ensure that your
// intention is to change the default implementation.
@Override
public String toString() {
    return String.format( "%s[email=%s, first name=%s, last name=%s]", 
        getClass().getSimpleName(), email, firstName, lastName );
}

final Person person = new Person( "John", "Smith", "john.smith@domain.com" );
System.out.println( person.toString() );

Person[email=john.smith@domain.com, first name=John, last name=Smith]

package com.javacodegeeks.advanced.objects;

import java.util.Arrays;

public class Office {
    private Person[] persons;

    public Office( Person ... persons ) {
         this.persons = Arrays.copyOf( persons, persons.length );
    }
    
    @Override
    public String toString() {
        return String.format( "%s{persons=%s}", 
            getClass().getSimpleName(), Arrays.toString( persons ) );
    }
    
    public Person[] getPersons() {
        return persons;
    }
}

public class Person implements Cloneable {
    // Please add the @Override annotation, it will ensure that your
    // intention is to change the default implementation.
    @Override
    public Person clone() throws CloneNotSupportedException {
        return ( Person )super.clone();
    }
}

package com.javacodegeeks.advanced.objects;

import java.util.Arrays;

public class Office implements Cloneable {
    private Person[] persons;

    public Office( Person ... persons ) {
         this.persons = Arrays.copyOf( persons, persons.length );
    }

    @Override
    public Office clone() throws CloneNotSupportedException {
        return ( Office )super.clone();
    }
    
    public Person[] getPersons() {
        return persons;
    }
}

@Override
public Office clone() throws CloneNotSupportedException {
    final Office clone = ( Office )super.clone();
    clone.persons = persons.clone();
    return clone;
}

final String str1 = new String( "bbb" );
System.out.println( "Using == operator: " + ( str1 == "bbb" ) );
System.out.println( "Using equals() method: " + str1.equals( "bbb" ) );

@Override
public boolean equals( Object obj ) {
    if ( obj == null ) {
        return false;
    }
        
    if ( this == obj ) {
        return true;
    }
        
    if ( getClass() != obj.getClass() ) {
        return false;
    }
        
    final PersonObjects other = (PersonObjects) obj;
    if( !Objects.equals( email, other.email ) ) {
        return false;
    } else if( !Objects.equals( firstName, other.firstName ) ) {
        return false;            
    } else if( !Objects.equals( lastName, other.lastName ) ) {
        return false;            
    }
        
    return true;
}
        
@Override
public int hashCode() {
    return Objects.hash( email, firstName, lastName );
}      

public class StringBufferDemo01 {
    public static void main(String[] args) {
        // public StringBuffer():无参构造方法
        StringBuffer sb = new StringBuffer();
        System.out.println("sb:"+sb);
        System.out.println("sb.capacity:"+sb.capacity()); //16
        System.out.println("sb.length:"+sb.length()); //0
        System.out.println("--------------------------");
        // public StringBuffer(int capacity):指定容量的字符串缓冲区对象
        StringBuffer sb2 = new StringBuffer(50);
        System.out.println("sb2:"+sb2);
        System.out.println("sb2.capacity:"+sb2.capacity()); //50
        System.out.println("sb2.length:"+sb2.length()); //0
        System.out.println("--------------------------");
        // public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
        StringBuffer sb3 = new StringBuffer("hello");
        System.out.println("sb3:"+sb3); //"hello"
        System.out.println("sb3.capacity:"+sb3.capacity()); //21
        System.out.println("sb3.length:"+sb3.length());//5
        System.out.println("--------------------------");
    }
}

/
     * Constructs a string buffer with no characters in it and an
     * initial capacity of 16 characters.
     */
    public StringBuffer() {
        super(16);
    }
    /
     * Constructs a string buffer with no characters in it and
     * the specified initial capacity.
     *
     * @param      capacity  the initial capacity.
     * @exception  NegativeArraySizeException  if the <code>capacity</code>
     *               argument is less than <code>0</code>.
     */
    public StringBuffer(int capacity) {
        super(capacity);
    }
    /
     * Constructs a string buffer initialized to the contents of the
     * specified string. The initial capacity of the string buffer is
     * <code>16</code> plus the length of the string argument.
     *
     * @param   str   the initial contents of the buffer.
     * @exception NullPointerException if <code>str</code> is <code>null</code>
     */
    public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }

public class StringBufferDemo02 {
    public static void main(String[] args) {
        // 创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer();
        //返回对象本身
        StringBuffer sb2 = sb.append("hello");
        System.out.println("sb:"+sb); //sb:hello
        System.out.println("sb2:"+sb2); //sb2:hello
        System.out.println(sb == sb2); //true
        //一步一步的添加数据
        StringBuffer sb3 = new StringBuffer();
        sb3.append("hello");
        sb3.append(true);
        sb3.append(12);
        sb3.append(34.56);
        System.out.println("sb3:"+sb3); //sb3:hellotrue1234.56
        //链式编程
        StringBuffer sb4 = new StringBuffer();
        sb4.append("hello").append(true).append(12).append(34.56);
        System.out.println("sb4:"+sb4); //sb4:hellotrue1234.56
        //StringBuffer insert(int offset,Stringstr):插入数据
        sb3.insert(5,"hello");
        System.out.println("sb3:"+sb3); //sb3:hellohellotrue1234.56
    }
}

public class StringBufferDemo03 {
    public static void main(String[] args) {
        // 创建对象
        StringBuffer sb1 = new StringBuffer();
        // 创建对象
        sb1.append("hello").append("world").append("java");
        System.out.println("sb1:"+sb1); //sb1:helloworldjava
        // public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
        // 需求：我要删除e这个字符
        sb1.deleteCharAt(1);
        // 需求:我要删除第一个l这个字符
        sb1.deleteCharAt(1);
        System.out.println("sb1:"+sb1);  //sb1:hloworldjava
        System.out.println("----------------");
        // public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身
        StringBuffer sb2 = new StringBuffer("Hello World Java");
        System.out.println("sb2:"+sb2); //sb2:Hello World Java
        // 需求：我要删除World这个字符串
        sb2.delete(5,11);
        System.out.println("sb2:"+sb2); //sb2:Hello Java
        // 需求:我要删除所有的数据
        sb2.delete(0, sb2.length());
        System.out.println("sb2:"+sb2); //sb2:
    }
}

public class StringBufferDemo04 {
    public static void main(String[] args) {
        // 创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer();
        // 添加数据
        sb.append("hello");
        sb.append("world");
        sb.append("java");
        System.out.println("sb:" + sb); //sb:helloworldjava
        // public StringBuffer replace(int start,int end,String str):从start开始到end用str替换
        // 需求：我要把world这个数据替换为"节日快乐"
        sb.replace(5,10,"节日快乐");
        System.out.println("sb:"+sb); //sb:hello节日快乐java
    }
}

public class StringBufferDemo05 {
    public static void main(String[] args) {
        //创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer();
        //添加数据
        sb.append("林青霞爱我");
        System.out.println("sb:"+sb); //sb:林青霞爱我
        //public StringBuffer reverse()
        sb.reverse();
        System.out.println("sb:"+sb); //sb:我爱霞青林
    }
}

public class StringBufferDemo06 {
    public static void main(String[] args) {
        //创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer();
        sb.append("hello").append("world").append("java");
        System.out.println("sb:"+sb); //sb:helloworldjava
        //截取功能
        String s = sb.substring(5);
        System.out.println("s:"+s); //s:worldjava
        System.out.println("sb:"+sb); //sb:helloworldjava
        String ss = sb.substring(5,10);
        System.out.println("ss:"+ss); //ss:world
        System.out.println("sb:"+sb); //sb:helloworldjava
    }
}

public class StringBufferDemo07 {
    public static void main(String[] args) {
        //String --> StringBuffer
        String s = "hello";
        // 注意：不能把字符串的值直接赋值给StringBuffer
        // StringBuffer sb = "hello";
        // StringBuffer sb = s;
        //方式一：通过构造方法
        StringBuffer sb = new StringBuffer(s);
        //方式二：通过append方法
        StringBuffer sb2 = new StringBuffer();
        sb2.append(s);
        System.out.println("sb:"+sb); //sb:hello
        System.out.println("sb2:"+sb2); //sb2:hello
        System.out.println("-------------------------");
        //StringBuffer --> String
         StringBuffer buffer = new StringBuffer("java");
        //方式一：通过构造方法
        String str = new String(buffer);
        //方式二：通过toString()方法
        String str2 = buffer.toString();
        System.out.println("str:"+str); //str:java
        System.out.println("str2:"+str2); //str2:java
    }
}

public class StringBufferDemo08 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {44,33,55,11,22};
        //定义功能
        //方式一：用String做拼接的方式
        String result1 = arrayToString1(arr);
        System.out.println("result1:"+result1); //result1:[44,33,55,11,22]
        //方式二：用StringBuffer做拼接的方式
        String result2 = arrayToString2(arr);
        System.out.println("result2:"+result2); //result2:[44,33,55,11,22]
    }
    public static String arrayToString1(int[] arr){
        String s = "";
        s += "[";
        for(int x = 0; x < arr.length; x++){
            if (x == arr.length - 1){
                s += arr[x];
            }else{
                s += arr[x];
                s += ',';
            }
        }
        s += ']';
        return s;
    }
    public static String arrayToString2(int[] arr){
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        for(int x = 0; x < arr.length; x++){
            if (x == arr.length-1){
                sb.append(arr[x]);
            }else{
                sb.append(arr[x]).append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

public class StringBufferDemo09 {
    public static void main(String[] args) {
        String s = "I love Java";
        String result1 = myReverse1(s);
        System.out.println("result1:"+result1); //result1:avaJ evol I
        String result2 = myReverse2(s);
        System.out.println("result2:"+result2); //result2:avaJ evol I
    }
    public static String myReverse1(String s){
        String result = "";
        char[] ch = s.toCharArray();
        for(int x = s.length()-1; x >= 0; x--){
            result += ch[x];
        }
        return result;
    }
    public static String myReverse2(String s){
        return new StringBuffer(s).reverse().toString();
    }
}

public class StringBufferDemo10 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.nextLine();  //abcba
        boolean result1 = isSymmertrical1(str);
        System.out.println("result1:"+result1); //result1:true
        boolean result2 = isSymmertrical2(str); //result2:true
        System.out.println("result2:"+result2);
    }
    public static boolean isSymmertrical1(String s){
        boolean flag = true;
        char ch[] = s.toCharArray();
        for(int start = 0, end = ch.length-1; start <= end;start++,end--){
            if (ch[start] != ch[end]){
                flag = false;
                break;
            }
        }
        return flag;
    }
    public static boolean isSymmertrical2(String s){
        return new StringBuffer(s).reverse().toString().equals(s);
    }
}

public class StringBufferDemo11 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1 + "---" + s2);//hello---world
        change(s1, s2);
        System.out.println(s1 + "---" + s2);//hello---world
        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println(sb1 + "---" + sb2);//hello---world
        change(sb1, sb2);
        System.out.println(sb1 + "---" + sb2);//hello---worldworld
    }
    //Stringz作为形参传递不会改变实参
    public static void change(String s1, String s2) {
        s1 = s2;
        s2 = s1 + s2;
    }
    //StringBuffer作为形参，如果直接赋值则不会影响实参，但是如果是使用方法改变形参则会影响实参
    public static void change(StringBuffer sb1, StringBuffer sb2) {
        sb1 = sb2;
        sb2.append(sb1);
    }
}