1.5  与String的相互转换

String转成StringBuilder：

StringBuilder构造方法,或者append方法

StringBuilder转成String：

StringBuilder类的方法 public String toString()

练习：数组元素格式拼接 举例：int[] arr = {1,2,3};结果：[1, 2, 3]

public class Demo04StringBuilderTest {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1,2,3};
        //调用方法
        String s = arrayToString(arr);
        //输出结果
        System.out.println("s:" + s);
        /*写方法实现拼接
         * 两个明确：
         *         返回值类型：String
         *         参数列表：int[] arr
    public static String arrayToString(int[] arr){
        StringBuilder builder = new StringBuilder();
        builder.append("[");
        for(int x = 0;x < arr.length;x++){
            if(x==arr.length-1){
                builder.append(arr[x]).append("]");
            }else{
                builder.append(arr[x]).append(",");
        String result = builder.toString();
        return result;
字符串反转
import java.util.Scanner;
 * 字符串反转
public class Demo05StringBuilderTest {
    public static void main(String[] args) {
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s = sc.nextLine();
        //3.调用方法
        String result = myReverse(s);
        //4.输出结果
        System.out.println("result:"+result);
     * 2.写方法实现反转
     * 两个明确：
     *         返回值类型：string
     *         参数列表：String
    public static String myReverse(String s){
        //String -- StringBuilder -- reverse() -- String
        StringBuilder builder = new StringBuilder(s);
        builder.reverse();
        String result = builder.toString();
        return result;
判断字符串的对称性
	　　对称性是指一个字符串进行反转后,还和原来的字符串一致.
	　　例如: abcba,反转后还是abcba,反转前后是一致的
public class Demo06StringBuilderTest {
    public static void main(String[] args) {
        String str = "abcba";
        boolean bool = symmetric(str);
        System.out.println(bool);
     * 实现字符串对称判断
     * 返回布尔值
     *     参数类型：String
     *     返回值：boolean
    public static boolean symmetric(String str){
        //创建StringBuilder对象
        StringBuilder builder = new StringBuilder();
        //将字符串添加到容器
        builder.append(str);
        //反转字符串
        builder.reverse();
        //获取反转后的字符串
        String str2 = builder.toString();
        System.out.println(str2);//abcba
        //String类equals方法判断两个字符串是否相等
        return str.equals(str2);//true
第2章    ArrayList集合
2.1 对象数组的案例
创建一个学生数组，存储三个学生对象并遍历
 * 对象数组的案例
 *     创建一个学生数组，存储三个学生对象并遍历
public class Student {
    private String name;
    private int age;
    public Student(){
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    public String getName(){
        return name;
    public void setName(String name){
        this.name = name;
    public int getAge(){
        return age;
public class Demo01Array {
    public static void main(String[] args) {
        //创建数组
        Student[] students = new Student[3];
        //创建学生对象
        Student s1 = new Student("曹操",40);
        Student s2 = new Student("刘备",35);
        Student s3 = new Student("孙权",30);
        //把学生对象作为元素赋值给学生数组
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;
        //遍历学生数组
        for(int x = 0;x<students.length;x++){
            Student s = students[x];
            //System.out.println(s);
            System.out.println(s.getName()+"---"+s.getAge());
2.2 为什么出现集合类
我们学习的是面向对象语言，而面向对象语言对事物的描述是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储。
而要想存储多个对象，就不能是一个基本的变量，而应该是一个容器类型的变量，在我们目前所学过的知识里面，有哪些是容器类型的呢?数组和StringBuilder。
但是呢? StringBuilder的结果是一个字符串，不一定满足我们的要求，所以我们只能选择数组，这就是对象数组。
而对象数组又不能适应变化的需求，因为数组的长度是固定的，这个时候，为了适应变化的需求，Java就提供了集合类供我们使用，由此可见集合的长度是可变的。
2.3     ArrayList类的构造方法和成员方法
ArrayList<E>集合:大小可变数组的实现
<E>:是一种特殊的数据类型，泛型。
在出现E的地方我们使用引用数据类型替换即可
举例：ArrayList<String>,ArrayList<Student>
public ArrayList()：默认构造
public boolean add(E e):添加元素　　　　
public void add(int index,E element):在指定的索引处添加一个元素　　　　
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> list = new ArrayList<String>();
        //add(E e):添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //add.(int index,E element):在指定的索引出添加一个元素
        list.add(1, "android");
        System.out.println("array:"+list);
更多成员方法
public E get(int index):返回指定索引处的元素　　
public int size():返回集合中的元素的个数　　
public boolean remove(Object o):删除指定的元素，返回删除是否成功　　
public E remove(int index):删除指定索引处的元素，返回被删除的元素　　
public E set(int index,E element):修改指定索引处的元素，返回被修改的元素　　
import java.util.ArrayList;
public class Demo02ArrayList {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String>array = new ArrayList<String>();
        //添加元素
        array.add("hello");
        array.add("world");
        array.add("java");
        //public E get(int index):返回指定索引处的元素
        System.out.println("get:"+array.get(0));
        System.out.println("get:"+array.get(1));
        System.out.println("get:"+array.get(2));
        //public int size():返回集合中的元素的个数
        System.out.println("size:"+array.size());//3
        //public boolean remove(Object o):删除指定的元素，返回删除是否成功
        System.out.println("remove:"+array.remove("world"));//true
        System.out.println("remove:"+array.remove("world"));//false        
        //public E remove(int index):删除指定索引处的元素，返回被删除的元素
        System.out.println("remove:"+array.remove(0));//hello        
        //public E set(int index,E element):修改指定索引处的元素，返回被修改的元素
        System.out.println("set:"+array.set(0, "android"));//java        
        //输出
        System.out.println("array:"+array);//[android]
存储基本数据类型
byte         Byte
short        Short
int            Integer
long         Long
float         Float
long         Long
char         Character
boolean   Boolean 
使用集合存储整数该怎么存储？对于基本数据类型集合是不存储的，因此不能写int，但是可以存储基本类型的包装类型Integer。
public class Demo02ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        for(int x = 0;x<list.size();x++){
            Integer i = list.get(x);
            System.out.println(i);
1.1     ArrayList类案例
　　练习一：存储字符串并遍历。
public class Demo03ArrayList {
    public static void main(String[] args){
        //创建集合对象
        ArrayList<String>list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //获取元素
        //原始做法
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println("--------------");
        for(int i = 0;i < 3;i++){
            System.out.println(list.get(i));
        System.out.println("--------------");
        //如何知道集合中元素的个数呢？size()
        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        System.out.println("--------------");
        //最标准的用法
        for(int i = 0;i<list.size();i++){
            String s = list.get(i);
            System.out.println(s);
练习二：
	给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”}，
	将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上。
import java.util.ArrayList;
public class Demo03ArrayListTest {
    public static void main(String[] args) {
        //定义字符串数组
        String[] strArray = {"张三丰","宋远桥","张无忌","殷梨亭","张翠山","莫声谷"};
        //创建集合对象
        ArrayList<String>list = new ArrayList<String>();
        //遍历字符串数组，获取到每一个字符串元素
        for(int x = 0;x<strArray.length;x++){
            //把获取到的字符串元素添加到集合
            list.add(strArray[x]);
        //遍历集合
        for(int x = 0;x<list.size();x++){
            String s = list.get(x);
            //要判断每一个字符串元素是否以"张"开头，如果是，就输出在控制台
            if(s.startsWith("张")){
                System.out.println(s);