java面向对象第七天(--StringBuffer--StringBulider -- 权限修饰符:本类和不同包下子类的关系--)

1.如何判断一个字符串是否对称

private static void fun(){
  String str = "asddsa";
   //字符串转化成数组;
    char[] array = new String(array);
    for (int i = 0; i<array.length;i++){
        if(array[i]!=array[array.length-1-i]){    //判断第一项和最后一项是否相等,如果不相等结束程序执行;
          return;
      }
   }
   System.out.println(Arrays.toString(array))
}

2.数组的一些方法 sort(array);  Arrays.binarySearch( array, key(目标对象))

int [] array = { 5,7,9,22,1};
 //实现了数组从小到大的排序;
//该方法没有返回值,操作的是自己本身;
 Arrays.sort(array);

int [] array1 = { 1,2,3,6,77};
//如果返回值是负数.说明该数组中没有要找的这个数
//实际上返回的应该放的角标加1;
int index = Arrays.binarySearch(array,13);
System.out.pritln(index);

3.String -- StringBuffer---StringBuilder--当参数的区别;

String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）
 简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
 而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：
 String S1 = “This is only a” + “ simple” + “ test”;
 StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
 你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个
 String S1 = “This is only a” + “ simple” + “test”; 其实就是：
 String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：
String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;
这时候 JVM 会规规矩矩的按照原来的方式去做

在大部分情况下 StringBuffer > String
StringBuffer
Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。
在大部分情况下 StringBuilder > StringBuffer

java.lang.StringBuilde
java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

 注意:字符串在当参数的时候和基本数据类型是一样的;

public class Demo03三个操作字符串的类当做参数 {
	public static void main(String[] args) {
		//字符串当参数的时候和基本数据类型是一样的,是值得传递;
		String string = "wanglong";
		fun0(string);
		System.out.println(string); //打印结果是wanglong
		
		//相当于传进去的是对象地址;
		StringBuffer s =  new StringBuffer("wanglong");
		fun1(s);
		System.out.println(s); //打印结果是wanglonghaha
		
		StringBuilder sb2 = new StringBuilder("wanglong");
		  fun2(sb2);
		  System.out.println(sb2);

	}

	public static void fun0(String str) {
		str = "hahaha";

	}

	public static void fun1(StringBuffer sb) {
		sb.append("hahaha");

//打印结果是wanglonghaha

}

4.  ---StringBuffer---StringBuilder --特点和自身带的一些方法;

  1. StringBuffer:      是JDK1.0出来的;耗费系统资源;

  2.StringBuilder:    是JDK1.5出来的.线程不安全;节省系统的资源;

 3. 注意:  StringBuffer 和StringBuilder都是可变字符序列; 

        1. 相当于修改的是对象本身;

        2. 操作StringBuffer的方法一般是没有返回值的,可以直接打印原来的对象;

 StringBuffer的一些方法:

 1. 把一个字符数组转换成StringBuffer;

   char []  array5 ={ ' a', 'b', 'c'};

        1. //静态方法把数组转换成字符串;      或者直接转换;

          String string5= String.valueOf(array5); 或者 String string5=  new String(array5);

       2.再将字符串转变成StringBuffer类型;

          StringBuffer sb1 = new StringBuffer(string5);

2.把int[] array = new int []{ 1,2,3,4}.  采用拼接方法输出[ 1,2,3,4];    要求采用两种方法(String 和 StringBuffer;)

       1.采用String形式的:         

int [] array = new int [] {1,2,3,4}
  //声明空字符串用来拼接:
 String  string= "[";
  for (int i =0;i<arrays.length;i++){
      if(i==array.length-1){
        string= string+array[i]+"]";  
      }else{
         string = string+arr[i]+","
       }
}
 System.out.println(string);

 2.采用StringBuffer;      

   int [] array1 = new int[]{1,2,3,4,5};
     StringBuffer sb = new StringBuffer();
        sb.append("[");
        for(int i=0;i<array1.length;i++){
            if(i==array1.length-1){
                sb.append("i").append("]")
        }else{  
               sb.append("i").append(",")
      }
  
   }
        System.out.println(sb);

  3.StringBuffer 替换 ( replace (起始位置,数量,"替换为"))

   StringBuffer sb = new StringBuffer();
   sb.append("wanglong");
   //StringBuffer 修改的是自己本身;
   sb.replace( 0 , 4, "lixiao");
   sout(sb);

  4.StringBuffer: 反转功能(  reverse()  ) ;应用场景,将常量字符串 转变成 StringBuffer;在实现反转;

        例:  键盘输入字符串,然后将字符串进行反转;  

System.out.println("请输入字符串");
Scanner scanner = new Scanner (System.in);
String string = scanner.nextLine();
//StringBuffer sb = new StringBuffer(String); //将常量字符串转换成变量字符串;
    sb.reverse();
   System.out.pritln(sb);

5. StringBuffer : delete( start,end);   deleteCharAt(1); 

StringBuffer sb = new StringBuffer();
		sb.append("wanglong");
		// 留头不留尾巴[0.4)
		// 结束坐标大于字符串长度,相当于清空字符串;
		sb.delete(0, 4);
		System.out.println(sb);
		//注意字符''用的是单引号;
		//注意:直接传入的要删除字符的角标;
		sb.deleteCharAt(1);
		System.out.println(sb);
		
		//或取StringBuffer中空的字符;
		char c = sb.charAt(1);
		System.out.println(c);

6. StringBuffer:  插入 insert(位置,要替换的字符串)    setCharAt( 设置,'x') ;   

// 插入
		StringBuffer sb = new StringBuffer("wanglong");
		// 不能插入比零小的;
		sb.insert(4, "da").append("nb");
		System.out.println(sb);
		// 修改 没有返回值不能往后面接着.append等;
		sb.setCharAt(1, 'x'); //将第一位替换成字符X;

7.  StringBuffer:     初始容量:capacity()        字符串长度 : length();     转化成字符串: toString();

// 创建StringBuffer对象
		StringBuffer sb = new StringBuffer();
		// 打印初始容量,默认容量16'    return value.length
		System.out.println(sb.capacity());
		// 长度;
		System.out.println(sb.length());
		// 拼接 打印对象.相当于打印buffer.tostring()方法;
		// 不返回对象让你一直往下掉用;
		sb.append("wanglong").append("dalihahhah").append(false);
		System.out.println(sb);
		// StringBuffer转换成字符串类型;怎么转;
		String string = sb.toString();
		System.out.println(string)

8. 权限修饰符本类和不同包下子类的关系

package com.lanou3g.demo1;
/*
 * 测试权限修饰符
 * public(公开的);
 * protected (受保护)
 * default(默认 什么都不写) == buxie 
 * private(私有的)
 * 
 * 本类:      同包类    同包类    同包子类       不同包类      不同包子类
 *  public     y        y           y          y             y
 *  protected   y        y           y          y             N
 *  default     y        y           y           n            n
 *  private     y        n           n          n             n
 */
public class BenLei {
	private String name;

	public void sayHi() {
		System.out.println(name);
	}
}

9.基本数据类型包装类

* byte      Byte
 * short    Short
 * int        Integet
 * long      Long
 * float     Float
 * double     Double
 * boolean     Boolean
 * char        Character

		//Integer.valueOf(10);     这个方法你要知道;
		//如果值在[-128,+127]之间,实际上是从系统已经创建好的数组中取出一个值给你;
		//如果超过了这个区间,会新建一个对象,所以下面的地址不同;
		Integer num1=127; ;
		Integer num2 = 127;
		System.out.println(num1==num2);//都变成128 打印false 
		//equals比较的是字符串内容;
		System.out.println(num1.equals(num2)); 
		
		
		// 创建一个Integer
		Integer ne = new Integer(10);
		// 转换过数字
		int i = ne.intValue();
		System.out.println(i);

		// 一般直接用数字来声明;
		int a = 10;
	  //自动装箱 (valueOf)和自动拆箱(intValue);
		
		// 实际上系统帮你调用了一个方法Interger.valueOf(10)方法;
		// 基本数据类型变成了Integer数据类型
		
		Integer na = 10; //写全应该是系统帮你包装了; Integer ne = new Integer(10);;
		// 运算的时候会进行自动拆箱,相当于帮你调用一个方法
		// na.intValue 自动拆箱;
		int sum = na + 5;
		System.out.println(sum);
		
		
		Integer a1=1;
		int a2 = a1;//这时候系统就会将Integer类型的a1自动拆箱，把值取出来赋值给a2

	}
}