06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础

第06天 java基础语法

今日内容介绍
 Eclipse断点调试
 基础语法的练习

第1章 Eclipse断点调试

1.1 Eclipse断点调试概述
Eclipse的断点调试可以查看程序的执行流程和解决程序中的bug
1.2 Eclipse断点调试常用操作:
A:什么是断点：
就是一个标记，从哪里开始。
B:如何设置断点：
你想看哪里的程序，你就在那个有效程序的左边双击即可。
C:在哪里设置断点：
哪里不会点哪里。
目前：我们就在每个方法的第一条有效语句上都加。
D:如何运行设置断点后的程序：
右键 – Debug as – Java Application
E:看哪些地方：
Debug：断点测试的地方
在这个地方，记住F6，或者点击也可以。一次看一行的执行过程。
Variables：查看程序的变量变化
ForDemo：被查看的源文件
Console：控制台
F:如何去断点：
再次双击即可
找到Debug视图，Variables界面，找到Breakpoints，并点击，然后看到所有的断点，最后点击那个双叉。
1.2.1 案例代码一:

package com.itheima;/** 断点调试：*        A:查看程序的执行流程*        B:调试程序* * 断点：*       其实就是一个标记* * 在哪里加呢?*         想加哪里就加哪里，一般是加在我们看不懂的地方* * 如何加呢?*         在代码区域的最左边双击即可* * 如何运行加断点的程序呢?*      代码区域 -- 右键 -- Debug as -- Java Application*         会弹出一个页面让我们选择是否进入debug模式，选择yes。* * 如何让程序往下执行呢?*       Step Over 执行下一步 *       F6* * 看那些区域呢?*      代码区域：看程序的执行步骤*       Debug区域：看程序的执行步骤*        Variables：看变量的创建，赋值，销毁等*       Console：看程序的输入和输出* * 如何去除断点：*         A:把加断点的动作再来一遍*      B:在debug视图中，找到Breakpoints，选中断点，点击双x即可*/
public class DebugDemo {public static void main(String[] args) {int a = 10;int b = 20;int c = a + b;System.out.println(c);}
}

1.3 断点调试练习
1.3.1 案例代码二:

package com.itheima;/** 需求：看循环的执行流程(1-5求和案例)*/
public class DebugTest {public static void main(String[] args) {// 定义求和变量int sum = 0;// 循环获取每一个数据for (int x = 1; x <= 5; x++) {sum += x;}System.out.println("sum:" + sum);}
}

1.3.2 案例代码三:

package com.itheima;import java.util.Scanner;/** 需求：看方法的调用流程* * 有方法调用的时候，要想看到完整的流程，每个方法都要加断点，建议方法进入的第一条有效语句加断点*/
public class DebugTest2 {public static void main(String[] args) {// 创建对象Scanner sc = new Scanner(System.in);// 接收数据System.out.println("请输入第一个数据：");int a = sc.nextInt();System.out.println("请输入第二个数据：");int b = sc.nextInt();// 调用方法int result = sum(a, b);// 输出结果System.out.println("result:" + result);}// 求和方法public static int sum(int a, int b) {return a + b;}
}

1.3.3 案例代码四:

package com.itheima;
/** 参数是基本数据类型：*      形式参数的改变不影响实际参数。*/
public class DebugTest3 {public static void main(String[] args) {int a = 10;int b = 20;System.out.println("a:" + a + ",b:" + b);change(a, b);System.out.println("a:" + a + ",b:" + b);}public static void change(int a, int b) {System.out.println("a:" + a + ",b:" + b);a = b;b = a + b;System.out.println("a:" + a + ",b:" + b);}
}1.3.4  案例代码五:
package com.itheima;/** 参数是基本数据类型：*      形式参数的改变不影响实际参数。*/
public class DebugTest3 {public static void main(String[] args) {int a = 10;int b = 20;System.out.println("a:" + a + ",b:" + b);change(a, b);System.out.println("a:" + a + ",b:" + b);
}public static void change(int a, int b) {System.out.println("a:" + a + ",b:" + b);a = b;b = a + b;System.out.println("a:" + a + ",b:" + b);
}
}

第2章基础语法的练习

2.1 循环,if和switch练习
2.1.1 键盘录入月份，输出对应的季节(if…else或switch实现)
2.1.1.1 案例代码六:

package com.itheima;import java.util.Scanner;/** 需求：键盘录入一个月份，输出该月份对应的季节。*      一年有四季*      3,4,5   春季*         6,7,8   夏季*         9,10,11 秋季*         12,1,2  冬季* * 分析：*       A:键盘录入一个月份,用Scanner实现*      B:判断该月份是几月，根据月份输出对应的季节*          if*             switch*/
public class Test {public static void main(String[] args) {// 键盘录入一个月份,用Scanner实现Scanner sc = new Scanner(System.in);// 接收数据System.out.println("请输入一个月份(1-12)：");int month = sc.nextInt();// 判断该月份是几月，根据月份输出对应的季节/*if (month == 1) {System.out.println("冬季");} else if (month == 2) {System.out.println("冬季");} else if (month == 3) {System.out.println("春季");} else if (month == 4) {System.out.println("春季");} else if (month == 5) {System.out.println("春季");} else if (month == 6) {System.out.println("夏季");} else if (month == 7) {System.out.println("夏季");} else if (month == 8) {System.out.println("夏季");} else if (month == 9) {System.out.println("秋季");} else if (month == 10) {System.out.println("秋季");} else if (month == 11) {System.out.println("秋季");} else if (month == 12) {System.out.println("冬季");} else {System.out.println("你输入的月份有误");}*///代码太长了，能不能简单一些呢?//能，如何简单一些呢?//我们可以把相同季节的月份放到一起来判断//(month==3 || month==4 || month==5)if(month==1 || month==2 || month==12) {System.out.println("冬季");}else if(month==3 || month==4 || month==5) {System.out.println("春季");}else if(month==6 || month==7|| month==8) {System.out.println("夏季");}else if(month==9 || month==10 || month==11) {System.out.println("秋季");}else {System.out.println("你输入的月份有误");}}
}

2.1.1.2 案例代码七:

package com.itheima;import java.util.Scanner;/** 需求：键盘录入一个月份，输出该月份对应的季节。*      一年有四季*      3,4,5   春季*         6,7,8   夏季*         9,10,11 秋季*         12,1,2  冬季* * 分析：*       A:键盘录入一个月份,用Scanner实现*      B:判断该月份是几月，根据月份输出对应的季节*          if*             switch* * case穿透。*/
public class Test2 {public static void main(String[] args) {// 键盘录入一个月份,用Scanner实现Scanner sc = new Scanner(System.in);// 接收数据System.out.println("请输入月份(1-12)：");int month = sc.nextInt();// 用switch语句实现/*switch (month) {case 1:System.out.println("冬季");break;case 2:System.out.println("冬季");break;case 3:System.out.println("春季");break;case 4:System.out.println("春季");break;case 5:System.out.println("春季");break;case 6:System.out.println("夏季");break;case 7:System.out.println("夏季");break;case 8:System.out.println("夏季");break;case 9:System.out.println("秋季");break;case 10:System.out.println("秋季");break;case 11:System.out.println("秋季");break;case 12:System.out.println("冬季");break;default:System.out.println("你输入的月份有误");break;}*///case 穿透/*switch(month) {case 1:System.out.println("hello");//break;case 2:System.out.println("world");break;default:System.out.println("over");break;}*///通过case穿透现象改进代码switch(month) {case 1:case 2:case 12:System.out.println("冬季");break;case 3:case 4:case 5:System.out.println("春季");break;case 6:case 7:case 8:System.out.println("夏季");break;case 9:case 10:case 11:System.out.println("秋季");break;default:System.out.println("你输入的月份有误");break;}}
}

2.1.2 打印5位数中所有的回文数
2.1.2.1 案例代码八:

package com.itheima;
/** 需求：打印5位数中的所有回文数。*        什么是回文数呢?举例：12321是回文数，个位与万位相同，十位与千位相同。* * 分析：*       A:5位数告诉了我们数据的范围，用for循环实现*        B:获取每一个5位数，然后得到它的个位，十位，千位，万位*           假设x是一个5位数：*              个位：x%10*                 十位：x/10%10*              千位：x/10/10/10%10*                万位：x/10/10/10/10%10*         C:把满足条件的数据输出即可*/
public class Test3 {public static void main(String[] args) {//5位数告诉了我们数据的范围，用for循环实现for(int x=10000; x<100000; x++) {//获取每一个5位数，然后得到它的个位，十位，千位，万位int ge = x%10;int shi = x/10%10;int qian = x/10/10/10%10;int wan = x/10/10/10/10%10;//把满足条件的数据输出即可if((ge==wan) && (shi==qian)) {System.out.println(x);}}}
}

2.2 数组练习
2.2.1 不死神兔问题
2.2.1.1 案例代码九

package com.itheima;/** 需求：*      有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，*         假如兔子都不死，问第二十个月的兔子对数为多少？ * * 规律：*       第一个月：1*      第二个月：1*      第三个月：2*      第四个月：3*      第五个月：5*      ...* *      规律：从第三个月开始，每个月的兔子对数是前两个月的兔子对数之和。*             第一个月和第二个月的兔子对数是1* 分析：*       int[] arr = new int[20];* *        arr[0] = 1;*       arr[1] = 1;* *         arr[2] = arr[0] + arr[1];*        arr[3] = arr[1] + arr[2];*        arr[4] = arr[2] + arr[3];*        ...*/
public class Test4 {public static void main(String[] args) {//定义数组int[] arr = new int[20];//初始化第一个月和第二个月的兔子对数carr[0] = 1;arr[1] = 1;for(int x=2; x<arr.length; x++) {arr[x] = arr[x-2] + arr[x-1];}System.out.println("第二十个月的时候的兔子对数是："+arr[19]);}
}

2.2.2 求数组中满足要求的元素和
2.2.2.1 案例代码十:

package com.itheima;/** 需求：* (1)定义一个int类型的一维数组，内容为{171,72,19,16,118,51,210,7,18}* (2)求出该数组中满足要求的元素和。*      要求：求和的元素的个位和十位不能包含7,并且只能为偶数。* * 分析：*      A:定义一个int类型的一维数组*       B:定义一个求和变量*         C:遍历数组，获取到数组中的每一个元素*         D:判断该元素是否满足如下要求，如果是就累加，否则，不搭理它*            x%2==0*           x%10 != 7*             x/10%10 !=7*       E:输出结果*/
public class Test5 {public static void main(String[] args) {//定义一个int类型的一维数组int[] arr = {171,72,19,16,118,51,210,7,18};//定义一个求和变量int sum = 0;//遍历数组，获取到数组中的每一个元素for(int x=0; x<arr.length; x++) {if((arr[x]%10 != 7) && (arr[x]/10%10 != 7) && (arr[x]%2 == 0)) {sum += arr[x];}}System.out.println("sum:"+sum);}
}

2.2.3 裁判评分
2.2.3.1 案例代码十一:

package com.itheima;import java.util.Scanner;/** 需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。* 选手的最后得分为：去掉一个最高分和一个最低分后 其余4个选手的平均值。* 请写代码实现。(不考虑小数部分)* * 分析：*         A:定义一个长度为6的数组。*         B:通过键盘录入的方式给出评委的分数*         C:写方法实现获取数组中的最大值，最小值*        D:写方法实现数组元素的求和*         E:平均分： (和-最高分-最低分)/(arr.length-2)*       F:输出分数即可*/
public class Test6 {public static void main(String[] args) {//定义一个长度为6的数组int[] arr = new int[6];//通过键盘录入的方式给出评委的分数Scanner sc = new Scanner(System.in);for(int x=0; x<arr.length; x++) {// arr[x] = sc.nextInt();System.out.println("请给出第"+(x+1)+"个评委的分数(0-100)：");int number = sc.nextInt();arr[x] = number;}//写方法实现获取数组中的最大值，最小值int max = getMax(arr);int min = getMin(arr);//写方法实现数组元素的求和int sum = sum(arr);// (和-最高分-最低分)/(arr.length-2)int avg = (sum-max-min)/(arr.length-2);//输出分数即可System.out.println("该选手的最终得分是："+avg);}//数组元素求和public static int sum(int[] arr) {int sum = 0;for(int x=0; x<arr.length; x++) {sum += arr[x];}return sum;}//数组中的最小值public static int getMin(int[] arr) {int min = arr[0];for(int x=1; x<arr.length; x++) {if(arr[x] < min) {min = arr[x];}}return min;}//数组中的最大值public static int getMax(int[] arr) {int max = arr[0];for(int x=1; x<arr.length; x++) {if(arr[x] > max) {max = arr[x];}}return max;}
}

2.2.4 数组反转
2.2.4.1 案例代码十二:

package com.itheima;
import java.util.Scanner;/** 需求：* (1)键盘录入5个int类型的数据存储数组arr中* (2)定义方法将arr数组中的内容反转* (3)定义方法对反转后的数组进行遍历* * 分析：*      A:定义一个长度为5的数组*      B:通过键盘录入数据给数组中的元素赋值*        C:定义方法将arr数组中的内容反转*             什么是反转?如何反转?*        D:定义方法遍历数组*/
public class Test7 {public static void main(String[] args) {// 定义一个长度为5的数组int[] arr = new int[5];// 通过键盘录入数据给数组中的元素赋值Scanner sc = new Scanner(System.in);for (int x = 0; x < arr.length; x++) {System.out.println("请给出第" + (x + 1) + "个元素");arr[x] = sc.nextInt();}System.out.println("反转前的数组元素：");printArray(arr);// 定义方法将arr数组中的内容反转reverse(arr);System.out.println("反转后的数组元素：");//定义方法遍历数组printArray(arr);}//遍历数组public static void printArray(int[] arr) {System.out.print("[");for(int x=0;x<arr.length; x++){if(x == arr.length-1) {System.out.println(arr[x]+"]");}else {System.out.print(arr[x]+", ");}}}/** 两个明确： 返回值类型：void 参数列表：int[] arr*/public static void reverse(int[] arr) {for(int startIndex=0,endIndex=arr.length-1;startIndex<=endIndex;startIndex++,endIndex--) {int temp = arr[startIndex];arr[startIndex] = arr[endIndex];arr[endIndex] = temp;}}
}

2.2.5 数组基本查找
2.2.5.1 案例代码十三:

package com.itheima;
import java.util.Scanner;
/**需求：数组元素查找(查找指定元素第一次在数组中出现的索引)*(1)给定数组int[] arr = {5,7,3,2,5};*(2)要查询的元素通过键盘录入的方式确定*(3)定义一个查找数组元素第一次出现位置的方法(注,要查找的元素就是键盘录入的数据)**分析：*       A:给定数组int[] arr = {5,7,3,2,5};*        B:要查询的元素通过键盘录入的方式确定*        C:定义一个查找数组元素第一次出现位置的方法*         遍历数组，获取到每一个元素，进行比较，如果想等，就直接把该处的索引返回。*       D:调用方法，输出结果*/
public class Test8 {public static void main(String[] args) {// 给定数组int[] arr = {5,7,3,2,5};int[] arr = { 5, 7, 3, 2, 5 };//要查询的元素通过键盘录入的方式确定Scanner sc = new Scanner(System.in);System.out.println("请输入要查找的元素：");int number = sc.nextInt();//定义一个查找数组元素第一次出现位置的方法//调用方法int index =getIndex(arr, number);System.out.println("index:"+index);}/** 两个明确：*      返回值类型：int*       参数列表：int[] arr,int value*/public static int getIndex(int[] arr,int value) {//遍历数组，获取到每一个元素，进行比较，如果想等，就直接把该处的索引返回。/*for(int x=0; x<arr.length; x++) {if(arr[x] == value) {return x;}}return -1;*/int index = -1;for(int x=0; x<arr.length; x++) {if(arr[x] == value) {index = x;break;}}return index;}
}

2.2.6 数据加密
2.2.6.1 案例代码十四:

package com.itheima;import java.util.Scanner;/** 需求：键盘录入数据,要求数据是四位的整数,现需要对数据进行加密,加密规则如下:* 每位数字都加上5,然后除以10的余数代替该数字,* 再将第一位和第四位交换,第二位和第三位交换,* 请把加密后的数据输出到控制台* * 分析：*         A:键盘录入一个四位数*        B:对数据进行加密*          举例：*                 4567*               把这个四位数分成个，十，百，千存储到数组中*                 int[] arr = {4,5,6,7};*                每位数字都加上5：*                   arr[x] += 5;  {9,10,11,12}*               然后除以10的余数代替该数字：*                     arr[x] %= 10;  {9,0,1,2}*               再将第一位和第四位交换,第二位和第三位交换：*                     {9,0,1,2}       {2,1,0,9}*      C:输出加密后的数据*/
public class Test9 {public static void main(String[] args) {//键盘录入一个四位数Scanner sc = new Scanner(System.in);//接收数据System.out.println("请输入一个四位数：");int number = sc.nextInt();//分别得到该数据的每一个位上的数据int ge = number%10;int shi = number/10%10;int bai = number/10/10%10;int qian = number/10/10/10%10;//定义一个数组int[] arr = new int[4];arr[0] = qian;arr[1] = bai;arr[2] = shi;arr[3] = ge;//加密规则//每位数字都加上5,然后除以10的余数代替该数字for(int x=0; x<arr.length; x++) {arr[x] += 5;arr[x] %= 10;}//再将第一位和第四位交换,第二位和第三位交换int temp = arr[0];arr[0] = arr[3];arr[3] = temp;int temp2 = arr[1];arr[1] = arr[2];arr[2] = temp2;//输出加密后的数据for(int x=0; x<arr.length; x++) {System.out.print(arr[x]);}System.out.println();}
}

第07天面向对象基础

今日内容介绍
 面向对象概述
 面向对象特性之封装
 面向对象之构造方法
 类名作为形参和返回值案例

第1章面向对象概述

1.1 面向对象思想
1.1.1 面向过程思想与面向对象思想
A:什么是面向过程
面向过程，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
例如:吃煎饼果子利用面向过程的思想:
1.学习摊煎饼的技术
2.买材料鸡蛋,油,葱等等
3.开始摊
4.吃
5.收拾
B:什么是面向对象
面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。（如果有对象，直接用对象，对我们直接提供服务）
例如:吃煎饼果子利用面向对象的思想

找会摊煎饼的大妈(创建一个摊煎饼大妈的对象)
调用其摊煎饼的技能(功能),传递进去钱参数
返回给我们一个煎饼
吃
1.1.2 面向过程特点与面向对象特点
A:面向过程：
强调的是过程，所有事情都需要自己完成
B:面向对象:
是一种更符合我们思想习惯的思想(懒人思想，我把事情自己不做，交给别人去做)
可以将复杂的事情简单化（对使用者来说简单了，对象里面还是很复杂的）
将我们从执行者变成了指挥者角色发生了转换
1.1.2.1 案例代码一:

  package com.itheima_01;
/** 面向对象思想：*         面向对象是基于面向过程的编程思想。* *        面向过程：强调的是每一个功能的步骤*       面向对象：强调的是对象，然后由对象去调用功能* * 面向对象的思想特点：*      A:是一种更符合我们思考习惯的思想*      B:可以将复杂的事情简单化*      C:将我们从执行者变成了指挥者* * 举例：*      买电脑：*            面向过程：我要买电脑--我要明确买电脑的意义--上网查对应的参数信息--去中关村买电脑--讨价还价--买回电脑*             面向对象：我要买电脑--班长去给我买电脑--买回电脑*      洗衣服：*            面向过程：把衣服脱下来--找一个盆--放点洗衣粉--加点水--浸泡10分钟--揉一揉--清洗衣服--拧干--晾起来*           面向对象：把衣服脱下来--打开全自动洗衣机--扔衣服--按钮--晾起来*/
public class Demo {}

1.2 类与对象及其使用:
1.2.1 类与对象概述:
A:我们学习编程是为了什么
为了把我们日常生活中实物用学习语言描述出来
B:我们如何描述现实世界事物
属性就是该事物的描述信息(事物身上的名词)
行为就是该事物能够做什么(事物身上的动词)
C:Java中最基本的单位是类,Java中用class描述事物也是如此
成员变量就是事物的属性
成员方法就是事物的行为
D:定义类其实就是定义类的成员(成员变量和成员方法)
a:成员变量和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
b:成员方法和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
E:类和对象的概念
a:类：是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）
b:对象：是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）
c:举例：
类学生
对象具体的某个学生就是一个对象
比如：车是一个类，具体的开的奔驰、宝马，就是对象
1.2.1.1 案例代码二:

package com.itheima_01;
/** 我们学习编程语言，其实就是为了把现实世界的事物模拟出来，实现信息化。* * 我们是如何表示现实世界的事物的呢?*      A:属性    就是事物的描述信息*      B:行为    就是事物能够做什么*      举例：学生* * Java语言最基本的单位是类，所以，我们在后面的学习过程中，是通过类来体现现实世界事物的。* * 类：是一组相关的属性和行为的集合* 对象：就是该事物的具体体现*        举例：*             类       学生*             对象      班长*/
public class Demo2 {}
1.2.2   类与对象案例:
1.2.2.1 学生类案例
1.2.2.1.1   案例代码三:
package com.itheima_02;
/** 类的定义：*       类是用来描述现实世界的事物的* * 事物：*       属性  事物的描述信息*        行为  事物能够做什么* * 类是如何和事物进行对应的呢?*      类：*          成员变量*           成员方法* * 需求：写一个学生类* * 学生事物：*       属性：姓名，年龄...*      行为：学习，吃饭...* * 学生类：*       成员变量：姓名,年龄*      成员方法：学习,吃饭** 成员变量：和我们前面学习过的变量的定义是一样的。*        位置不同：类中，方法外*      初始化值：不需要给初始化值* 成员方法：和我们前面学习过的方法的定义是一样的。*      去掉static关键字*/
public class Student {//成员变量//姓名String name;//年龄int age;//成员方法//学习的方法public void study() {System.out.println("好好学习，天天向上");}//吃饭的方法public void eat() {System.out.println("学习饿了要吃饭");}
}package com.itheima_02;
/** Student是一个学生事物描述类，main方法不适合放在它里面。* * 使用一个类，其实就是使用该类的成员。(成员变量和成员方法)* 而我们要想使用一个类的成员，就必须首先拥有该类的对象。* 我们如何拥有一个类的对象呢?*       创建对象就可以了?* 我们如何创建对象呢?*      格式：类名 对象名 = new 类名();* 对象如何访问成员呢?*      成员变量：对象名.变量名*        成员方法：对象名.方法名(...)*/
public class StudentDemo {public static void main(String[] args) {//格式：类名 对象名 = new 类名();Student s = new Student();//System.out.println("s:"+s); //com.itheima_02.Student@193c0cf//直接输出成员变量值System.out.println("姓名："+s.name); //nullSystem.out.println("年龄："+s.age); //0System.out.println("----------");//给成员变量赋值s.name = "林青霞";s.age = 28;//再次输出成员变量的值System.out.println("姓名："+s.name); //林青霞System.out.println("年龄："+s.age); //28System.out.println("----------");//调用成员方法s.study();s.eat();}
}

1.2.2.2 手机类案例
1.2.2.2.1 案例代码四:

package com.itheima_02;
/** 手机类：*        成员变量：品牌，价格，颜色...*      成员方法：打电话，发短信...*/
public class Phone {//品牌String brand;//价格int price;//颜色String color;//打电话public void call(String name) {System.out.println("给"+name+"打电话");}//发短信public void sendMessage() {System.out.println("群发短信");}
}package com.itheima_02;
/** 手机类的测试类*/
public class PhoneDemo {public static void main(String[] args) {//创建对象Phone p = new Phone();//输出成员变量值System.out.println("品牌："+p.brand);//nullSystem.out.println("价格："+p.price);//0System.out.println("颜色："+p.color);//nullSystem.out.println("------------");//给成员变量赋值p.brand = "锤子";p.price = 2999;p.color = "棕色";//再次输出成员变量值System.out.println("品牌："+p.brand);//锤子System.out.println("价格："+p.price);//2999System.out.println("颜色："+p.color);//棕色System.out.println("------------");//调用成员方法p.call("林青霞");p.sendMessage();}
}

1.3 对象的内存图
1.3.1 一个对象的内存图:

1.3.2 方法公用内存图:
1.3.2.1 案例代码五:

package com.itheima_03;
/** 手机类的测试类*/
public class PhoneDemo2 {public static void main(String[] args) {Phone p = new Phone();p.brand = "小米5s";p.price = 1999;p.color = "银色";System.out.println(p.brand+"---"+p.price+"---"+p.color);p.call("林青霞");p.sendMessage();Phone p2 = new Phone();p2.brand = "IPhone7S";p2.price = 7999;p2.color = "土豪金";System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);p2.call("张曼玉");p2.sendMessage();}
}

1.3.3 两个引用指向同一个对象内存图:

1.3.3.1 案例代码六:

package com.itheima_03;
/** 手机类的测试类*/
public class PhoneDemo3 {public static void main(String[] args) {Phone p = new Phone();p.brand = "OPPO";p.price = 2999;p.color = "白色";System.out.println(p.brand+"---"+p.price+"---"+p.color);Phone p2 = p;p2.brand = "魅族";p2.price = 1999;p2.color = "蓝色";System.out.println(p.brand+"---"+p.price+"---"+p.color);System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);}
}

1.4 成员变量和局部变量区别:
1.4.1 案例代码七:

package com.itheima_04;
/** 成员变量和局部变量的区别：*       A:在类中的位置不同*             成员变量：类中，方法外*          局部变量：方法中或者方法声明上(形式参数)*       B:在内存中的位置不同*            成员变量：堆内存*            局部变量：栈内存*        C:生命周期不同*           成员变量：随着对象的创建而存在，随着对象的消失而消失*           局部变量：随着方法的调用而存在，随着方法的调用完毕而消失*         D:初始化值的问题*          成员变量：有默认值*           局部变量：没有默认值。必须先定义，赋值，最后使用*/
public class Variable {int x;public void show() {int y = 0;System.out.println(x);System.out.println(y);}
}

第2章面向对象特性之封装

2.1 封装与私有关键字
2.1.1 private关键字
A:private关键字：
a:是一个权限修饰符。
b:可以修饰成员(成员变量和成员方法)
c:被private修饰的成员只在本类中才能访问。

2.1.1.1 案例代码八:

package com.itheima_05;
/** 学生类* * 通过对象直接访问成员变量，会存在数据安全问题* 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢?* 能。* 如何实现呢?*         private关键字* * private:*         是一个修饰符*         可以修饰成员变量，也可以修饰成员方法*      被private修饰的成员只能在本类中被访问* * 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰*/
public class Student {String name;//int age;private int age;public void setAge(int a) {if(a<0 || a>200) {System.out.println("你给的年龄有误");}else {age = a;}}public int getAge() {return age;}public void show() {System.out.println("姓名是："+name+",年龄是："+age);}
}

package com.itheima_05;
/** 学生类的测试类*/
public class StudentDemo {public static void main(String[] args) {//创建学生对象Student s = new Student();s.show();s.name = "林青霞";//s.age = 28;//s.age = -28;//s.setAge(-28);s.setAge(28);s.show();}
}

2.1.2 private最常见应用
A:把成员变量用private修饰
B:提供对应的getXxx()/setXxx()方法
2.1.2.1 案例代码九:


package com.itheima_06;
/** 学生类*/
public class Student {private String name;private int age;public void setName(String n) {name = n;}public String getName() {return name;}public void setAge(int a) {age = a;}public int getAge() {return age;}
}

package com.itheima_06;
/** 学生类的测试类*/
public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();System.out.println(s.getName()+"---"+s.getAge());s.setName("林青霞");s.setAge(28);System.out.println(s.getName()+"---"+s.getAge());}
}

2.1.3 封装的概述和好处:
A:封装概述
是面向对象三大特征之一
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
B:封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
成员变量private，提供对应的getXxx()/setXxx()方法
C:好处：
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性

2.2 this关键字
2.2.1 this关键字由来和使用:
A:this:代表所在类的对象引用
方法被哪个对象调用，this就代表那个对象
B:什么时候使用this呢
局部变量和成员变量重名

2.2.1.1 案例代码十:
package com.itheima_07;

/** 学生类* * 起名字我们要求做到见名知意。* 而我们现在的代码中的n和a就没有做到见名知意，所以我要改进。* * 如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近的原则。* * 我们有没有办法把局部变量的name赋值给成员变量的name呢?* 有。* * 什么办法呢?*         用this关键字就可以解决这个问题* * this:代表所在类的对象引用*       方法被哪个对象调用，this就代表那个对象* * 使用场景：*       局部变量隐藏成员变量*/
public class Student {private String name;private int age;public void setName(String name) { //"林青霞"//name = name;this.name = name;}public String getName() {return name;}public void setAge(int age) {//age = age;this.age = age;}public int getAge() {return age;}
}package com.itheima_07;
/** 学生类的测试类*/
public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();System.out.println(s.getName()+"---"+s.getAge());s.setName("林青霞");s.setAge(28);System.out.println(s.getName()+"---"+s.getAge());}
}

第3章面向对象之构造方法

3.1 构造方法:
主要用来给对象的数据进行初始化
3.1.1 构造方法格式:
A:构造方法格式
a:方法名与类名相同
b:没有返回值类型，连void都没有
c:没有具体的返回值
3.1.1.1 案例代码十一:

package com.itheima_08;
/** 构造方法：*       给对象的数据进行初始化* * 格式：*      方法名和类名相同*       没有返回值类型，连void都不能写*       没有具体的返回值**/
public class Student {  public Student() {System.out.println("这是构造方法");}
}

package com.itheima_08;public class StudentDemo {public static void main(String[] args) {//如何调用构造方法呢?//通过new关键字调用//格式：类名 对象名 = new 构造方法(...);Student s = new Student();}
}

3.1.2 构造方法注意事项与重载
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的,重载条件和普通方法相同
3.1.2.1 案例代码十二:

package com.itheima_08;
/** 构造方法：*       给对象的数据进行初始化* * 格式：*      方法名和类名相同*       没有返回值类型，连void都不能写*       没有具体的返回值* * 构造方法的注意事项：*      A:如果我们没有给出构造方法，系统将会提供一个默认的无参构造方法供我们使用。*      B:如果我们给出了构造方法，系统将不在提供默认的无参构造方法供我们使用。*        这个时候，如果我们想使用无参构造方法，就必须自己提供。*        推荐：自己给无参构造方法*      C:构造方法也是可以重载的* * 成员变量赋值：*        A:setXxx()方法*       B:带参构造方法    */
public class Student {private String name;private int age;/*public Student() {System.out.println("这是构造方法");}*/public Student() {}public Student(String name) {this.name = name;}public Student(int age) {this.age = age;}public Student(String name,int age) {this.name = name;this.age = age;}public void show() {System.out.println(name+"---"+age);}
}package com.itheima_08;public class StudentDemo {public static void main(String[] args) {//如何调用构造方法呢?//通过new关键字调用//格式：类名 对象名 = new 构造方法(...);Student s = new Student();s.show();//public Student(String name)Student s2 = new Student("林青霞");s2.show();//public Student(int age)Student s3 = new Student(28);s3.show();//public Student(String name,int age)Student s4 = new Student("林青霞",28);s4.show();}
}

3.1.3 包含private,无参,有参构造的标准学生类代码:
A:类:
a:成员变量
b:构造方法
无参构造方法
带参构造方法
c:成员方法
getXxx()
setXxx()
B:给成员变量赋值的方式
a:无参构造方法+setXxx()
b:带参构造方法
3.1.3.1 案例代码十三:

package com.itheima_09;
/** 学生类*/
public class Student {//成员变量private String name;private int age;//构造方法public Student() {}public Student(String name,int age) {this.name = name;this.age = age;}//成员方法public void setName(String name) {this.name = name;}public String getName() {return name;}public void setAge(int age) {this.age = age;}public int getAge() {return age;}
}package com.itheima_09;
/** 学生类的测试类*/
public class StudentDemo {public static void main(String[] args) {//无参+setXxx()Student s = new  Student();s.setName("林青霞");s.setAge(28);System.out.println(s.getName()+"---"+s.getAge());//带参构造Student s2 = new Student("林青霞",28);System.out.println(s2.getName()+"---"+s2.getAge());}
}

第4章类名作为形参和返回值

4.1 类名作为方法的形式参数
4.1.1 案例代码十四:

package com.itheima_10;public class Student {public void study() {System.out.println("好好学习,天天向上");}
}package com.itheima_10;public class Teacher {public void test(Student s) {//接收传递过来的Student对象的地址值s.study();                  }
}

package com.itheima_10;//需求： 调用Teacher的test方法//类名作为形式参数：其实这里需要的是该类对象。
public class Test {public static void main(String[] args) {Teacher t = new Teacher();Student s = new Student();t.test(s);}
}

4.2 类名作为返回值案例
4.2.1 案例代码十五:

package com.itheima_11;public class Student {public void study() {System.out.println("好好学习,天天向上");}
}package com.itheima_11;public class Teacher {public Student getStudent() {Student s = new Student();return s;//返回的是Student对象的地址值}
}


package com.itheima_11;//需求： 通过Teacher得到Student对象，然后调用Student类的方法
//如果方法的返回值是类名：其实返回的是该类的对象
public class Test {public static void main(String[] args) {Teacher t = new Teacher();Student s = t.getStudent();s.study();}
}

第08天常用API

今日内容介绍
 API概述
 Scanner类与String类
 StringBuilder类

第1章 API概述

1.1 API概念
API(Application Programming Interface) : 应用程序编程接口
编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类
1.2 快速使用API步骤:
A:打开帮助文档
B:点击显示，找到索引，看到输入框
C:你要学习什么内容，你就在框框里面输入什么内容
举例：Random
D:看包
java.lang包下的类在使用的时候是不需要导包的
E:看类的描述
Random类是用于生成随机数的类
F:看构造方法
Random():无参构造方法
Random r = new Random();
G:看成员方法
public int nextInt(int n):产生的是一个[0,n)范围内的随机数
调用方法：
看返回值类型：人家返回什么类型，你就用什么类型接收
看方法名：名字不要写错了
看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的
int number = r.nextInt(100);

第2章 Scanner类与 String类

2.1 Scanner类
2.1.1 Scanner类作用
用Scanner类的方法可以完成接收键盘录入的数据
2.1.2 Scanner类接受键盘录入的字符串
2.1.2.1 案例代码一:

package com.itheima_01;
import java.util.Scanner;
/** Scanner:用于获取键盘录入的数据。(基本数据类型，字符串数据)* public String nextLine():获取键盘录入的字符串数据*/
public class ScannerDemo {public static void main(String[] args) {//创建键盘录入对象Scanner sc = new Scanner(System.in);//接收数据System.out.println("请输入一个字符串数据：");String s = sc.nextLine();//输出结果System.out.println("s:"+s);}
}

2.2 String类
2.2.1 String类概述
通过JDK提供的API，查看String类的说明
A:"abc"是String类的一个实例,或者成为String类的一个对象
B:字符串字面值"abc"也可以看成是一个字符串对象
C:字符串是常量，一旦被赋值，就不能被改变
D:字符串本质是一个字符数组
2.2.2 String类的构造方法
String(String original):把字符串数据封装成字符串对象
String(char[] value):把字符数组的数据封装成字符串对象
String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
2.2.2.1 常用构造方法演示
2.2.2.1.1 案例代码二:

package com.itheima_02;
/** String:字符串类*        由多个字符组成的一串数据*       字符串其本质是一个字符数组* * 构造方法：*      String(String original):把字符串数据封装成字符串对象*         String(char[] value):把字符数组的数据封装成字符串对象*      String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象* * 注意：字符串是一种比较特殊的引用数据类型，直接输出字符串对象输出的是该对象中的数据。*/
public class StringDemo {public static void main(String[] args) {//方式1//String(String original):把字符串数据封装成字符串对象String s1 = new String("hello");System.out.println("s1:"+s1);System.out.println("---------");//方式2//String(char[] value):把字符数组的数据封装成字符串对象char[] chs = {'h','e','l','l','o'};String s2 = new String(chs);System.out.println("s2:"+s2);System.out.println("---------");//方式3//String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象//String s3 = new String(chs,0,chs.length);String s3 = new String(chs,1,3);System.out.println("s3:"+s3);System.out.println("---------");//方式4String s4 = "hello";System.out.println("s4:"+s4);}
}

2.2.2.2 创建字符串对象两种方式的区别
2.2.2.2.1 案例代码三:

package com.itheima_02;
/** 通过构造方法创建的字符串对象和直接赋值方式创建的字符串对象有什么区别呢?*       通过构造方法创建字符串对象是在堆内存。*        直接赋值方式创建对象是在方法区的常量池。*       * ==:*        基本数据类型：比较的是基本数据类型的值是否相同*         引用数据类型：比较的是引用数据类型的地址值是否相同*/
public class StringDemo2 {public static void main(String[] args) {String s1 = new String("hello");String s2 = "hello";System.out.println("s1:"+s1);System.out.println("s2:"+s2);System.out.println("s1==s2:"+(s1==s2)); //falseString s3 = "hello";System.out.println("s1==s3:"+(s1==s3)); //falseSystem.out.println("s2==s3:"+(s2==s3)); //true}
}

2.2.3 String类的判断功能
boolean equals(Object obj):比较字符串的内容是否相同
boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
boolean startsWith(String str):判断字符串对象是否以指定的str开头
boolean endsWith(String str):判断字符串对象是否以指定的str结尾
2.2.3.1 判断方法演示
2.2.3.1.1 案例代码四:

package com.itheima_03;
/** Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。* 如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。* * String类的判断功能：* boolean equals(Object obj):比较字符串的内容是否相同* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写* boolean startsWith(String str):判断字符串对象是否以指定的str开头* boolean endsWith(String str):判断字符串对象是否以指定的str结尾*/
public class StringDemo {public static void main(String[] args) {//创建字符串对象String s1 = "hello";String s2 = "hello";String s3 = "Hello";//boolean equals(Object obj):比较字符串的内容是否相同System.out.println(s1.equals(s2));System.out.println(s1.equals(s3));System.out.println("-----------");//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写System.out.println(s1.equalsIgnoreCase(s2));System.out.println(s1.equalsIgnoreCase(s3));System.out.println("-----------");//boolean startsWith(String str):判断字符串对象是否以指定的str开头System.out.println(s1.startsWith("he"));System.out.println(s1.startsWith("ll"));}
}

2.2.3.2 判断功能案例
需求:模拟登录,给三次机会,并提示还有几次
2.2.3.2.1 案例代码五:

package com.itheima_03;import java.util.Scanner;/** 模拟登录,给三次机会,并提示还有几次。* * 分析：*       A:定义两个字符串对象，用于存储已经存在的用户名和密码*         B:键盘录入用户名和密码*       C:拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较*             如果内容相同，提示登录成功*           如果内容不同，提示登录失败，并提示还有几次机会*/
public class StringTest {public static void main(String[] args) {//定义两个字符串对象，用于存储已经存在的用户名和密码String username = "admin";String password = "admin";//给三次机会，用for循环实现for(int x=0; x<3; x++) {//键盘录入用户名和密码Scanner sc = new Scanner(System.in);System.out.println("请输入用户名：");String name = sc.nextLine();System.out.println("请输入密码：");String pwd = sc.nextLine();//拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较if(username.equals(name) && password.equals(pwd)) {System.out.println("登录成功");break;}else {if((2-x) ==0) {System.out.println("用户名和密码被锁定,请与管理员联系");}else {System.out.println("登录失败,你还有"+(2-x)+"次机会"); //2,1,0}}}}
}

2.2.4 String类的获取功能
2.2.4.1 获取方法演示

package com.itheima_04;
/** String类的获取功能：* int length():获取字符串的长度，其实也就是字符个数* char charAt(int index):获取指定索引处的字符* int indexOf(String str):获取str在字符串对象中第一次出现的索引* String substring(int start):从start开始截取字符串* String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end*/
public class StringDemo {public static void main(String[] args) {//创建字符串对象String s = "helloworld";//int length():获取字符串的长度，其实也就是字符个数System.out.println(s.length());System.out.println("--------");//char charAt(int index):获取指定索引处的字符System.out.println(s.charAt(0));System.out.println(s.charAt(1));System.out.println("--------");//int indexOf(String str):获取str在字符串对象中第一次出现的索引System.out.println(s.indexOf("l"));System.out.println(s.indexOf("owo"));System.out.println(s.indexOf("ak"));System.out.println("--------");//String substring(int start):从start开始截取字符串System.out.println(s.substring(0));System.out.println(s.substring(5));System.out.println("--------");//String substring(int start,int end):从start开始，到end结束截取字符串System.out.println(s.substring(0, s.length()));System.out.println(s.substring(3,8));}
}

2.2.4.2 获取功能案例
2.2.4.2.1 案例代码六:

package com.itheima_04;
/** 遍历字符串(获取字符串中的每一个字符)*/
public class StringTest {public static void main(String[] args) {//创建一个字符串对象String s = "abcde";//原始做法System.out.println(s.charAt(0));System.out.println(s.charAt(1));System.out.println(s.charAt(2));System.out.println(s.charAt(3));System.out.println(s.charAt(4));System.out.println("---------");//用for循环改进for(int x=0; x<5; x++) {System.out.println(s.charAt(x));}System.out.println("---------");//用length()方法获取字符串的长度for(int x=0; x<s.length(); x++) {System.out.println(s.charAt(x));}}
}

2.2.4.2.2 案例代码七:

package com.itheima_04;import java.util.Scanner;/** 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)* * 分析：*       A:键盘录入一个字符串数据*      B:定义三个统计变量，初始化值都是0*      C:遍历字符串，得到每一个字符*         D:拿字符进行判断*          假如ch是一个字符。*             大写：ch>='A' && ch<='Z'*           小写：ch>='a' && ch<='z'*           数字：ch>='0' && ch<='9'*       E:输出结果*/
public class StringTest2 {public static void main(String[] args) {//键盘录入一个字符串数据Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串数据：");String s = sc.nextLine();//定义三个统计变量，初始化值都是0int bigCount = 0;int smallCount = 0;int numberCount = 0;//遍历字符串，得到每一个字符for(int x=0; x<s.length(); x++) {char ch = s.charAt(x);//拿字符进行判断if(ch>='A' && ch<='Z') {bigCount++;}else if(ch>='a' && ch<='z') {smallCount++;}else if(ch>='0' && ch<='9') {numberCount++;}else {System.out.println("该字符"+ch+"非法");}}//输出结果System.out.println("大写字符："+bigCount+"个");System.out.println("小写字符："+smallCount+"个");System.out.println("数字字符："+numberCount+"个");}
}

2.2.5 String类的转换功能
2.2.5.1 转换方法演示
char[] toCharArray():把字符串转换为字符数组
String toLowerCase():把字符串转换为小写字符串
String toUpperCase():把字符串转换为大写字符串
2.2.5.1.1 案例代码八:

package com.itheima_05;
/** String类的转换功能：* char[] toCharArray():把字符串转换为字符数组* String toLowerCase():把字符串转换为小写字符串* String toUpperCase():把字符串转换为大写字符串* * 字符串的遍历：*         A:length()加上charAt()*       B:把字符串转换为字符数组，然后遍历数组*/
public class StringDemo {public static void main(String[] args) {//创建字符串对象String s = "abcde";//char[] toCharArray():把字符串转换为字符数组char[] chs = s.toCharArray();for(int x=0; x<chs.length; x++) {System.out.println(chs[x]);}System.out.println("-----------");//String toLowerCase():把字符串转换为小写字符串System.out.println("HelloWorld".toLowerCase());//String toUpperCase():把字符串转换为大写字符串System.out.println("HelloWorld".toUpperCase());}
}

2.2.5.2 转换功能案例
2.2.5.2.1 案例代码九:

package com.itheima_05;import java.util.Scanner;/** 键盘录入一个字符串，把该字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)* * 分析：*        A:键盘录入一个字符串*        B:截取首字母*        C:截取除了首字母以外的字符串*        D:B转大写+C转小写*       E:输出即可*/
public class StringTest {public static void main(String[] args) {//键盘录入一个字符串Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String s = sc.nextLine();//截取首字母String s1 = s.substring(0, 1);//截取除了首字母以外的字符串String s2 = s.substring(1);//B转大写+C转小写String s3 = s1.toUpperCase()+s2.toLowerCase();//输出即可System.out.println("s3:"+s3);}
}

2.2.6 String类的其它功能
2.2.6.1 其它方法演示
2.2.6.1.1 案例代码十:

package com.itheima_06;
/** 去除字符串两端空格   *       String trim()* 按照指定符号分割字符串  *       String[] split(String str)*/
public class StringDemo {public static void main(String[] args) {//创建字符串对象String s1 = "helloworld";String s2 = "  helloworld  ";String s3 = "  hello  world  ";System.out.println("---"+s1+"---");System.out.println("---"+s1.trim()+"---");System.out.println("---"+s2+"---");System.out.println("---"+s2.trim()+"---");System.out.println("---"+s3+"---");System.out.println("---"+s3.trim()+"---");System.out.println("-------------------");//String[] split(String str)//创建字符串对象String s4 = "aa,bb,cc";String[] strArray = s4.split(",");for(int x=0; x<strArray.length; x++) {System.out.println(strArray[x]);}}
}

2.2.7 String类的其它案例
2.2.7.1 案例代码十一:

package com.itheima_07;
/** 把数组中的数据按照指定个格式拼接成一个字符串* 举例：int[] arr = {1,2,3}; * 输出结果：[1, 2, 3]* * 分析：*      A:定义一个int类型的数组*         B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串*      C:调用方法*         D:输出结果*/
public class StringTest {public static void main(String[] args) {//定义一个int类型的数组int[] arr = {1,2,3};//写方法实现把数组中的元素按照指定的格式拼接成一个字符串//调用方法String s = arrayToString(arr);//输出结果System.out.println("s:"+s);}/** 两个明确：*        返回值类型：String*        参数列表：int[] arr*/public static String arrayToString(int[] arr) {String s = "";//[1, 2, 3]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;}
}

2.2.7.2 案例代码十二:

package com.itheima_07;import java.util.Scanner;/** 字符串反转* 举例：键盘录入”abc”       * 输出结果：”cba”* * 分析：*      A:键盘录入一个字符串*        B:写方法实现字符串的反转*          a:把字符串倒着遍历，得到的每一个字符拼接成字符串。*          b:把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串*         C:调用方法*         D:输出结果*/
public class StringTest2 {public static void main(String[] args) {//键盘录入一个字符串Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String s = sc.nextLine();//写方法实现字符串的反转//调用方法String result = reverse(s);//输出结果System.out.println("result:"+result);}/** 把字符串倒着遍历，得到的每一个字符拼接成字符串。* * 两个明确：*         返回值类型：String*        参数列表：String s*//*public static String reverse(String s) {String ss = "";for(int x=s.length()-1; x>=0; x--) {ss += s.charAt(x);}return ss;}*///把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串public static String reverse(String s) {//把字符串转换为字符数组char[] chs = s.toCharArray();//对字符数组进行反转for(int start=0,end=chs.length-1; start<=end; start++,end--) {char temp = chs[start];chs[start] = chs[end];chs[end] = temp;}//最后在把字符数组转换为字符串String ss = new String(chs);return ss;}
}

第3章 StringBuilder类

3.1 StringBuilder类概述
StringBuilder:是一个可变的字符串。字符串缓冲区类。
String和StringBuilder的区别：
String的内容是固定的
StringBuilder的内容是可变的
3.1.1 +=拼接字符串耗费内存原因:
每次拼接都会产生新的字符串对象,而利用StringBuilder来拼接字符串自始至终用的都是同一个StringBuilder容器

3.2 StringBuilder类的常用方法
A:构造方法:
StringBuilder()
B:成员方法:
public int capacity():返回当前容量 (理论值)
public int length():返回长度(已经存储的字符个数)
public StringBuilder append(任意类型):添加数据，并返回自身对象
public StringBuilder reverse():反转功能
3.2.1 案例代码十三:

package com.itheima_01;
/** StringBuilder:是一个可变的字符串。字符串缓冲区类。* * String和StringBuilder的区别：*        String的内容是固定的。*         StringBuilder的内容是可变的。* * 构造方法：*      StringBuilder()* * 成员方法：*        public int capacity():返回当前容量*       public int length():返回长度（字符数）* *      容量：理论值*      长度：实际值*/
public class StringBuilderDemo {public static void main(String[] args) {//创建对象StringBuilder sb = new StringBuilder();System.out.println("sb:"+sb);System.out.println("sb.capacity():"+sb.capacity());System.out.println("sb.length():"+sb.length());}
}

3.2.2 案例代码十四:

package com.itheima_02;
/** 添加功能*       public StringBuilder append(任意类型):添加数据，并返回自身对象* 反转功能*        public StringBuilder reverse()*/
public class StringBuilderDemo {public static void main(String[] args) {//创建对象StringBuilder sb = new StringBuilder();//public StringBuilder append(任意类型)//StringBuilder sb2 = sb.append("hello");/*System.out.println("sb:"+sb);System.out.println("sb2:"+sb2);System.out.println(sb == sb2); //true*//*sb.append("hello");sb.append("world");sb.append(true);sb.append(100);*///链式编程sb.append("hello").append("world").append(true).append(100);System.out.println("sb:"+sb);//public StringBuilder reverse()sb.reverse();System.out.println("sb:"+sb);}
}

3.3 StringBuilder案例
3.3.1 案例一需求:
StringBuilder和String通过方法完成相互转换
3.3.1.1 案例代码十五:

package com.itheima_03;
/** StringBuilder和String的相互转换* * StringBuilder -- String*       public String toString():通过toString()就可以实现把StringBuilder转成String* * String -- StringBuilder*        StringBuilder(String str):通过构造方法就可以实现把String转成StringBuilder*/
public class StringBuilderTest {public static void main(String[] args) {//StringBuilder -- String/*StringBuilder sb = new StringBuilder();sb.append("hello").append("world");String s = sb.toString();System.out.println(s);*///String -- StringBuilderString s = "helloworld";StringBuilder sb = new StringBuilder(s);System.out.println(sb);}
}

3.3.2 案例二需求:
利用StringBuilder把数组拼接成一个字符串
举例：
int[] arr = {1,2,3};
结果：
[1, 2, 3]
3.3.2.1 案例代码十六:

package com.itheima_03;
/** 把数组拼接成一个字符串* 举例：*        int[] arr = {1,2,3};* 结果：*      [1, 2, 3]*/
public class StringBuilderTest2 {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 sb = new StringBuilder();//[1, 2, 3]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("]");String result = sb.toString();return result;}
}

3.3.3 案例三需求:
利用StringBuilder完成字符串反转
3.3.3.1 案例代码十七:

package com.itheima_03;import java.util.Scanner;/** 把字符串反转* * 分析：*        A:键盘录入一个字符串*        B:写方法实现反转*          String -- StringBuilder -- reverse() -- String*         C:调用方法*         D:输出结果*/
public class StringBuilderTest3 {public static void main(String[] args) {//键盘录入一个字符串Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String s = sc.nextLine();//写方法实现反转//调用方法String result = myReverse(s);//输出结果System.out.println("result:"+result);}/** 两个明确：*       返回值类型：String*        参数列表：String*/public static String myReverse(String s) {//String -- StringBuilder -- reverse() -- StringStringBuilder sb = new StringBuilder(s);sb.reverse();String result = sb.toString();return result;}
}

3.3.4 案例四需求:
判断一个字符串是否是对称字符串
例如"abc"不是对称字符串，“aba”、“abba”、“aaa”、"mnanm"是对称字符串
3.3.4.1 案例代码十八:

package com.itheima_03;
import java.util.Scanner;/** 判断一个字符串是否是对称字符串* 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串* * 分析：*       A:键盘录入一个字符串*        B:写方法实现判断一个字符串是否是对称字符串*             把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串*      C:调用方法*         D:输出结果*/
public class StringBuilderTest4 {public static void main(String[] args) {//键盘录入一个字符串Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String s = sc.nextLine();//写方法实现判断一个字符串是否是对称字符串//调用方法boolean b = isSymmetry(s);//输出结果System.out.println("b:"+b);}/** 两个明确：*       返回值类型：boolean*       参数列表：String s*/public static boolean isSymmetry(String s) {//把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串StringBuilder sb = new StringBuilder(s);sb.reverse();String result = sb.toString();return result.equals(s);}
}

第09天 java集合

今日内容介绍
对象数组
集合类之ArrayList
学生管理系统案例

第1章对象数组

1.1对象数组概述
A:基本类型的数组:存储的元素为基本类型
int[] arr={1,2,3,4}
B:对象数组:存储的元素为引用类型
Student[] stus=new Student[3];

Student代表一个自定义类
Stus数组中stus[0],stus[1],stus[2]的元素数据类型为Student,
都可以指向一个Student对象
1.2对象数组案例:
创建一个学生数组，存储三个学生对象并遍历
1.2.1 案例代码一:

  package com.itheima;
/** 自动生成构造方法：*       代码区域右键 -- Source -- Generate Constructors from Superclass...    无参构造方法*         代码区域右键 -- Source -- Generate Constructor using Fields...        带参构造方法* 自动生成getXxx()/setXxx():*         代码区域右键 -- Source -- Generate Getters and Setters...*/
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 void setAge(int age) {this.age = age;}}

package com.itheima;
/** 创建一个学生数组，存储三个学生对象并遍历* * 分析：*      A:定义学生类*        B:创建学生数组*       C:创建学生对象*       D:把学生对象作为元素赋值给学生数组*         E:遍历学生数组*/
public class StudentDemo {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());}}
}

1.3对象数组的内存图

第2章集合类之ArrayList

2.1集合概述
A:我们学习的是面向对象编程语言，而面向对象编程语言对事物的描述都是通过对象来体现的。
为了方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要想对多个对象进行存储，就不能是一个基本的变量，而应该是一个容器类型的变量。

B:到目前为止，我们学习过了哪些容器类型的数据呢？
StringBuilder,数组。
StringBuilder的结果只能是一个字符串类型，不一定满足我们的需求。
所以，我们目前只能选择数组了，也就是我们前面学习过的对象数组。
但是，数组的长度是固定的，如果有时候元素的个数不确定的,我们无法定义出数组的长度,这个时候，java就提供了集合类供我们使用。
2.2ArrayList集合
2.2.1ArrayList添加新元素
2.2.1.1案例代码二:

package com.itheima_01;import java.util.ArrayList;/** 为什么会出现集合类：*         我们学习的是面向对象编程语言，而面向对象编程语言对事物的描述都是通过对象来体现的。*       为了方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要想对多个对象进行存储，*       就不能是一个基本的变量，而应该是一个容器类型的变量。*      到目前为止，我们学习过了哪些容器类型的数据呢？StringBuilder,数组。*         StringBuilder的结果只能是一个字符串类型，不一定满足我们的需求。*      所以，我们目前只能选择数组了，也就是我们前面学习过的对象数组。*      但是，数组的长度是固定的，适应不了变化的需求，那么，我们该如何选择呢?*        这个时候，java就提供了集合类供我们使用。* * 集合类的特点：*        长度可变。* * ArrayList<E>:*       大小可变数组的实现* *        <E>:是一种特殊的数据类型，泛型。*        怎么用呢?*          在出现E的地方我们使用引用数据类型替换即可*          举例：ArrayList<String>,ArrayList<Student>* * 构造方法：*         ArrayList()* * 添加元素：*        public boolean add(E e):添加元素*       public void add(int index,E element):在指定的索引处添加一个元素*/
public class ArrayListDemo {public static void main(String[] args) {//创建集合对象ArrayList<String> array = new  ArrayList<String>();//add(E e):添加元素array.add("hello");array.add("world");array.add("java");//add(int index,E element):在指定的索引处添加一个元素//array.add(1, "android");System.out.println("array:"+array);}
}

2.2.2ArrayList删改查方法
A:获取元素
public E get(int index):返回指定索引处的元素
B:集合长度
public int size():返回集合中的元素的个数
C:删除元素
public boolean remove(Object o):删除指定的元素，返回删除是否成功
public E remove(int index):删除指定索引处的元素，返回被删除的元素
D:修改元素
public E set(int index,E element):修改指定索引处的元素，返回被修改的元素

2.2.2.1案例代码三:

package com.itheima_01;import java.util.ArrayList;/** 获取元素*      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):修改指定索引处的元素，返回被修改的元素*/
public class ArrayListDemo2 {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());//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));//public E set(int index,E element):修改指定索引处的元素，返回被修改的元素System.out.println("set:"+array.set(1, "android"));//输出System.out.println("array:"+array);}
}

2.2.3ArrayList遍历
集合的遍历思想和数组的遍历思想相同
循环遍历容器,依次取出里面的元素即可
2.2.3.1案例代码四:

package com.itheima_01;
import java.util.ArrayList;/** ArrayList集合的遍历*      通过size()和get()配合实现的*/
public class ArrayListDemo3 {public static void main(String[] args) {//创建集合对象ArrayList<String> array = new ArrayList<String>();//添加元素array.add("hello");array.add("world");array.add("java");//获取元素//原始做法System.out.println(array.get(0));System.out.println(array.get(1));System.out.println(array.get(2));System.out.println("----------");for(int x=0; x<3; x++) {System.out.println(array.get(x));}System.out.println("----------");//如何知道集合中元素的个数呢?size()for(int x=0; x<array.size(); x++) {System.out.println(array.get(x));}System.out.println("----------");//最标准的用法for(int x=0; x<array.size(); x++) {String s = array.get(x);System.out.println(s);}}
}

2.3ArrayList集合案例
2.3.1ArrayList练习之存储字符串并遍历
向集合中添加任意四个字符串,遍历集合,依次打印取出的字符串
2.3.1.1案例代码五:

package com.itheima_02;
import java.util.ArrayList;/** 存储字符串并遍历* * 分析：*      A:创建集合对象*       B:添加字符串元素*      C:遍历集合*/
public class ArrayListTest {public static void main(String[] args) {//创建集合对象ArrayList<String> array = new ArrayList<String>();//添加字符串元素array.add("向问天");array.add("刘正风");array.add("左冷禅");array.add("风清扬");//遍历集合for(int x=0; x<array.size(); x++) {String s = array.get(x);System.out.println(s);}}
}

2.3.2ArrayList练习之获取满足要求的元素
给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”“张翠山”,“莫声谷”}，将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上
2.3.2.1案例代码六:

package com.itheima_02;
import java.util.ArrayList;
/** 给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”}，将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上。* * 分析：*         A:定义字符串数组*      B:创建集合对象*       C:遍历字符串数组，获取到每一个字符串元素*       D:把获取到的字符串元素添加到集合*      E:遍历集合*             要判断每一个字符串元素是否以"张"开头，如果是，就输出在控制台*/
public class ArrayListTest2 {public static void main(String[] args) {//定义字符串数组String[] strArray = {"张三丰","宋远桥","张无忌","殷梨亭","张翠山","莫声谷"};//创建集合对象ArrayList<String> array = new ArrayList<String>();//遍历字符串数组，获取到每一个字符串元素for(int x=0; x<strArray.length; x++) {//把获取到的字符串元素添加到集合array.add(strArray[x]);}//遍历集合for(int x=0; x<array.size(); x++) {String s = array.get(x);//要判断每一个字符串元素是否以"张"开头，如果是，就输出在控制台if(s.startsWith("张")) {System.out.println(s);}}}
}

2.3.3ArrayList练习之存储自定义对象并遍历
A:自定义一个学生类,学生中有姓名和年龄属性,生成满参构造与空参构造
生成属性对应的getter/setter方法

B:在测试类中使用满参构造创建三个学生对象,然后将每个学生对象均添加到ArrayList集合中

C:遍历这个ArrayList集合,依次打印出每个学生的姓名和年龄
2.3.3.1案例代码七:

package com.itheima_02;
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 void setAge(int age) {this.age = age;}
}

package com.itheima_02;
import java.util.ArrayList;/** 存储自定义对象并遍历* * 分析：*        A:定义学生类*        B:创建集合对象*       C:创建学生对象*       D:把学生对象作为元素添加到集合中*      E:遍历集合*/
public class ArrayListTest3 {public static void main(String[] args) {//创建集合对象ArrayList<Student> array = new ArrayList<Student>();//创建学生对象Student s1 = new Student("林青霞",28);Student s2 = new Student("张曼玉",30);Student s3 = new Student("景甜",25);Student s4 = new Student("柳岩",18);//把学生对象作为元素添加到集合中array.add(s1);array.add(s2);array.add(s3);array.add(s4);//遍历集合for(int x=0; x<array.size(); x++) {Student s = array.get(x);System.out.println(s.getName()+"---"+s.getAge());}}
}

2.3.4ArrayList练习之键盘录入数据存储并遍历
创建一个Student类包含姓名和年龄属性
创建一个ArrayList集合
向集合中添加三个Student对象Student对象中姓名和年龄的数据均来自与键盘录入
最终遍历这个集合,取出Student对象以及里面属性的值
2.3.4.1案例代码八:

package com.itheima_03;public class Student {private String name;private String age;public Student() {}public Student(String name, String age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}}

package com.itheima_03;import java.util.ArrayList;
import java.util.Scanner;/** 创建一个集合，存储学生对象，学生对象的数据来自于键盘录入，最后，遍历集合* * 注意：为了方便使用，我把学生类中的所有成员定义为String类型* * 分析：*      A:定义学生类*        B:创建集合对象*       C:键盘录入数据,创建学生对象,把键盘录入的数据赋值给学生对象的成员变量*       D:把学生对象作为元素存储到集合中*      E:遍历集合* */
public class StudentDemo {public static void main(String[] args) {//创建集合对象ArrayList<Student> array = new ArrayList<Student>();/*//键盘录入数据,创建学生对象,把键盘录入的数据赋值给学生对象的成员变量Scanner sc = new Scanner(System.in);System.out.println("请输入学生姓名：");String name = sc.nextLine();System.out.println("请输入学生年龄：");String age = sc.nextLine();Student s = new Student();s.setName(name);s.setAge(age);//把学生对象作为元素存储到集合中array.add(s);*///为了提高代码的复用性，我把键盘录入数据给学生对象，并存储到集合中的动作用一个方法来实现//调用方法addStudent(array);addStudent(array);addStudent(array);//遍历集合for(int x=0; x<array.size(); x++) {Student s = array.get(x);System.out.println(s.getName()+"---"+s.getAge());}}/** 两个明确：*        返回值类型：void*      参数列表：ArrayList<Student> array*/public static void addStudent(ArrayList<Student> array) {//键盘录入数据,创建学生对象,把键盘录入的数据赋值给学生对象的成员变量Scanner sc = new Scanner(System.in);System.out.println("请输入学生姓名：");String name = sc.nextLine();System.out.println("请输入学生年龄：");String age = sc.nextLine();Student s = new Student();s.setName(name);s.setAge(age);//把学生对象作为元素存储到集合中array.add(s);}
}

第3章学生管理系统案例

3.1学生管理系统案例需求

  利用集合完成对学生的增删改查四个功能

3.2学生管理系统案例实现
3.2.1创建学生类:
3.2.1.1案例代码九:

package com.itheima;
/** 这是我的学生类*/
public class Student {//学号private String id;//姓名private String name;//年龄private String age;//居住地private String address;public Student() {}public Student(String id, String name, String age, String address) {this.id = id;this.name = name;this.age = age;this.address = address;}public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}}

3.2.2学生管理系统界面实现:
3.2.2.1案例代码十:

package com.itheima;
import java.util.ArrayList;
import java.util.Scanner;/** 这是我的学生管理系统的主类* * 步骤如下：* A:定义学生类* B:学生管理系统的主界面的代码编写* C:学生管理系统的查看所有学生的代码编写* D:学生管理系统的添加学生的代码编写* E:学生管理系统的删除学生的代码编写* F:学生管理系统的修改学生的代码编写*/
public class StudentManagerTest {public static void main(String[] args) {// 创建集合对象，用于存储学生数据ArrayList<Student> array = new ArrayList<Student>();// 为了让程序能够回到这里来，我们使用循环while (true) {// 这是学生管理系统的主界面System.out.println("--------欢迎来到学生管理系统--------");System.out.println("1 查看所有学生");System.out.println("2 添加学生");System.out.println("3 删除学生");System.out.println("4 修改学生");System.out.println("5 退出");System.out.println("请输入你的选择：");// 创建键盘录入对象Scanner sc = new Scanner(System.in);String choiceString = sc.nextLine();// 用switch语句实现选择switch (choiceString) {case "1":// 查看所有学生break;case "2":// 添加学生break;case "3":// 删除学生break;case "4":// 修改学生break;case "5":// 退出// System.out.println("谢谢你的使用");// break;default:System.out.println("谢谢你的使用");System.exit(0); // JVM退出break;}}}
}

3.2.3学生管理系统之查询所有学生功能
3.2.3.1案例代码十一:

package com.itheima.test;
import java.util.ArrayList;
import java.util.Scanner;/** 这是我的学生管理系统的主类* * 步骤如下：* A:定义学生类* B:学生管理系统的主界面的代码编写* C:学生管理系统的查看所有学生的代码编写* D:学生管理系统的添加学生的代码编写* E:学生管理系统的删除学生的代码编写* F:学生管理系统的修改学生的代码编写*/
public class StudentManagerTest {public static void main(String[] args) {//创建集合对象，用于存储学生数据ArrayList<Student> array = new ArrayList<Student>();//为了让程序能够回到这里来，我们使用循环while(true) {//这是学生管理系统的主界面System.out.println("--------欢迎来到学生管理系统--------");System.out.println("1 查看所有学生");System.out.println("2 添加学生");System.out.println("3 删除学生");System.out.println("4 修改学生");System.out.println("5 退出");System.out.println("请输入你的选择：");//创建键盘录入对象Scanner sc = new Scanner(System.in);String choiceString = sc.nextLine();//用switch语句实现选择switch(choiceString) {case "1"://查看所有学生findAllStudent(array);break;case "2"://添加学生break;case "3"://删除学生break;case "4"://修改学生break;case "5"://退出//System.out.println("谢谢你的使用");//break;default:System.out.println("谢谢你的使用");System.exit(0); //JVM退出break;}}}//查看所有学生public static void findAllStudent(ArrayList<Student> array) {//首先来判断集合中是否有数据，如果没有数据，就给出提示，并让该方法不继续往下执行if(array.size() == 0) {System.out.println("不好意思,目前没有学生信息可供查询,请回去重新选择你的操作");return;}//\t 其实就是一个tab键的位置System.out.println("学号\t\t姓名\t年龄\t居住地");for(int x=0; x<array.size(); x++) {Student s = array.get(x);System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress());}}
}

3.2.4学生管理系统之添加学生功能
3.2.4.1案例代码十二:

package com.itheima;import java.util.ArrayList;
import java.util.Scanner;/** 这是我的学生管理系统的主类* * 步骤如下：* A:定义学生类* B:学生管理系统的主界面的代码编写* C:学生管理系统的查看所有学生的代码编写* D:学生管理系统的添加学生的代码编写* E:学生管理系统的删除学生的代码编写* F:学生管理系统的修改学生的代码编写*/
public class StudentManagerTest {public static void main(String[] args) {//创建集合对象，用于存储学生数据ArrayList<Student> array = new ArrayList<Student>();//为了让程序能够回到这里来，我们使用循环while(true) {//这是学生管理系统的主界面System.out.println("--------欢迎来到学生管理系统--------");System.out.println("1 查看所有学生");System.out.println("2 添加学生");System.out.println("3 删除学生");System.out.println("4 修改学生");System.out.println("5 退出");System.out.println("请输入你的选择：");//创建键盘录入对象Scanner sc = new Scanner(System.in);String choiceString = sc.nextLine();//用switch语句实现选择switch(choiceString) {case "1"://查看所有学生break;case "2"://添加学生addStudent(array);break;case "3"://删除学生break;case "4"://修改学生break;case "5"://退出//System.out.println("谢谢你的使用");//break;default:System.out.println("谢谢你的使用");System.exit(0); //JVM退出break;}}}/*//添加学生public static void addStudent(ArrayList<Student> array) {//创建键盘录入对象Scanner sc = new Scanner(System.in);System.out.println("请输入学生学号：");String id = sc.nextLine();System.out.println("请输入学生姓名：");String name = sc.nextLine();System.out.println("请输入学生年龄：");String age = sc.nextLine();System.out.println("请输入学生居住地：");String address = sc.nextLine();//创建学生对象Student s = new Student();s.setId(id);s.setName(name);s.setAge(age);s.setAddress(address);//把学生对象作为元素添加到集合array.add(s);//给出提示System.out.println("添加学生成功");}*///添加学生public static void addStudent(ArrayList<Student> array) {//创建键盘录入对象Scanner sc = new Scanner(System.in);//为了让id能够被访问到，我们就把id定义在了循环的外面String id;//为了让代码能够回到这里，用循环while(true) {System.out.println("请输入学生学号：");//String id = sc.nextLine();id = sc.nextLine();//判断学号有没有被人占用//定义标记boolean flag = false;//遍历集合，得到每一个学生for(int x=0; x<array.size(); x++) {Student s = array.get(x);//获取该学生的学号，和键盘录入的学号进行比较if(s.getId().equals(id)) {flag = true; //说明学号被占用了break;}}if(flag) {System.out.println("你输入的学号已经被占用,请重新输入");}else {break; //结束循环}}System.out.println("请输入学生姓名：");String name = sc.nextLine();System.out.println("请输入学生年龄：");String age = sc.nextLine();System.out.println("请输入学生居住地：");String address = sc.nextLine();//创建学生对象Student s = new Student();s.setId(id);s.setName(name);s.setAge(age);s.setAddress(address);//把学生对象作为元素添加到集合array.add(s);//给出提示System.out.println("添加学生成功");}
}

3.2.5学生管理系统之删除学生功能
3.2.5.1案例代码十三:

package com.itheima;import java.util.ArrayList;
import java.util.Scanner;/** 这是我的学生管理系统的主类* * 步骤如下：* A:定义学生类* B:学生管理系统的主界面的代码编写* C:学生管理系统的查看所有学生的代码编写* D:学生管理系统的添加学生的代码编写* E:学生管理系统的删除学生的代码编写* F:学生管理系统的修改学生的代码编写*/
public class StudentManagerTest {public static void main(String[] args) {//创建集合对象，用于存储学生数据ArrayList<Student> array = new ArrayList<Student>();//为了让程序能够回到这里来，我们使用循环while(true) {//这是学生管理系统的主界面System.out.println("--------欢迎来到学生管理系统--------");System.out.println("1 查看所有学生");System.out.println("2 添加学生");System.out.println("3 删除学生");System.out.println("4 修改学生");System.out.println("5 退出");System.out.println("请输入你的选择：");//创建键盘录入对象Scanner sc = new Scanner(System.in);String choiceString = sc.nextLine();//用switch语句实现选择switch(choiceString) {case "1"://查看所有学生break;case "2"://添加学生break;case "3"://删除学生deleteStudent(array);break;case "4"://修改学生break;case "5"://退出//System.out.println("谢谢你的使用");//break;default:System.out.println("谢谢你的使用");System.exit(0); //JVM退出break;}}}//删除学生public static void deleteStudent(ArrayList<Student> array) {//删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生//创建键盘录入对象Scanner sc = new Scanner(System.in);System.out.println("请输入你要删除的学生的学号：");String id = sc.nextLine();/*//遍历集合for(int x=0; x<array.size(); x++) {//获取到每一个学生对象Student s = array.get(x);//拿这个学生对象的学号和键盘录入的学号进行比较if(s.getId().equals(id)) {array.remove(x); //根据索引删除break;}}//给出提示System.out.println("删除学生成功");*///我们必须给出学号不存在的时候的提示//定义一个索引int index = -1;//遍历集合for(int x=0; x<array.size(); x++) {//获取到每一个学生对象Student s = array.get(x);//拿这个学生对象的学号和键盘录入的学号进行比较if(s.getId().equals(id)) {index = x;break;}}if(index == -1) {System.out.println("不好意思,你要删除的学号对应的学生信息不存在,请回去重新你的选择");}else {array.remove(index);System.out.println("删除学生成功");}}}

3.2.6学生管理系统之修改学生功能
3.2.6.1案例代码十四:

package com.itheima;import java.util.ArrayList;
import java.util.Scanner;/** 这是我的学生管理系统的主类* * 步骤如下：* A:定义学生类* B:学生管理系统的主界面的代码编写* C:学生管理系统的查看所有学生的代码编写* D:学生管理系统的添加学生的代码编写* E:学生管理系统的删除学生的代码编写* F:学生管理系统的修改学生的代码编写*/
public class StudentManagerTest {public static void main(String[] args) {//创建集合对象，用于存储学生数据ArrayList<Student> array = new ArrayList<Student>();//为了让程序能够回到这里来，我们使用循环while(true) {//这是学生管理系统的主界面System.out.println("--------欢迎来到学生管理系统--------");System.out.println("1 查看所有学生");System.out.println("2 添加学生");System.out.println("3 删除学生");System.out.println("4 修改学生");System.out.println("5 退出");System.out.println("请输入你的选择：");//创建键盘录入对象Scanner sc = new Scanner(System.in);String choiceString = sc.nextLine();//用switch语句实现选择switch(choiceString) {case "1"://查看所有学生break;case "2"://添加学生break;case "3"://删除学生break;case "4"://修改学生updateStudent(array);break;case "5"://退出//System.out.println("谢谢你的使用");//break;default:System.out.println("谢谢你的使用");System.exit(0); //JVM退出break;}}}//修改学生public static void updateStudent(ArrayList<Student> array) {//修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生//创建键盘录入对象Scanner sc = new Scanner(System.in);System.out.println("请输入你要修改的学生的学号：");String id = sc.nextLine();//定义一个索引int index = -1;//遍历集合for(int x=0; x<array.size(); x++) {//获取每一个学生对象Student s = array.get(x);//拿学生对象的学号和键盘录入的学号进行比较if(s.getId().equals(id)) {index = x;break;}}if(index == -1) {System.out.println("不好意思,你要修改的学号对应的学生信息不存在,请回去重新你的选择");}else {System.out.println("请输入学生新姓名：");String name = sc.nextLine();System.out.println("请输入学生新年龄：");String age = sc.nextLine();System.out.println("请输入学生新居住地：");String address = sc.nextLine();//创建学生对象Student s = new Student();s.setId(id);s.setName(name);s.setAge(age);s.setAddress(address);//修改集合中的学生对象array.set(index, s);//给出提示System.out.println("修改学生成功");}}
}

第10天 IO

今日内容介绍
IO流概述及FileWriter类使用
FileReader类使用
缓冲流介绍和使用
IO流相关案例

第1章IO流概述及FileWriter类使用

1.1IO流概述及分类
IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的类都在IO包中
流按流向分为两种：输入流，输出流

1.2FileWriter类使用
A:打开帮助文档
B:点击显示，找到索引，看到输入框
C:你要学习什么内容，你就在框框里面输入什么内容
举例：Random
D:看包
java.lang包下的类在使用的时候是不需要导包的
E:看类的描述
Random类是用于生成随机数的类
F:看构造方法
Random():无参构造方法
Random r = new Random();
G:看成员方法
public int nextInt(int n):产生的是一个[0,n)范围内的随机数
调用方法：
看返回值类型：人家返回什么类型，你就用什么类型接收
看方法名：名字不要写错了
看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的
int number = r.nextInt(100);
1.2.1FileWriter向文件中写数据
A:FileWriter向文件中写数据操作步骤:
a:使用FileWriter流关联文件
b:利用FileWriter的写方法写数据
c:利用FileWriter的刷新方法将数据从内存刷到硬盘上
d:利用FileWriter的关流方法将释放占用的系统底层资源
B:FileWriter方法:
构造方法
FileWriter(String fileName) 传入一个文件的路径
成员方法
void write(String str) 向文件中写str
void flush() 将内存中的数据刷新到文件中
void close() 关流释放系统底层资源

1.2.1.1案例代码一:

package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;/** 需求：往文件中写数据*       写数据--输出流--FileWriter* * FileWriter:*        FileWriter(String fileName):传递一个文件名称* * 输出流写数据的步骤：*      A:创建输出流对象*      B:调用输出流对象的写数据的方法*       C:释放资源*/
public class FileWriterDemo {public static void main(String[] args) throws IOException {//创建输出流对象FileWriter fw = new FileWriter("d:\\a.txt");/** 创建输出流对象做了哪些事情:*         A:调用系统资源创建了一个文件*        B:创建输出流对象*      C:把输出流对象指向文件*///调用输出流对象的写数据的方法//写一个字符串数据fw.write("IO流你好");//数据没有直接写到文件，其实是写到了内存缓冲区fw.flush();//释放资源//通知系统释放和该文件相关的资源fw.close();//while(true) {}}
}

1.2.2FileWriter注意事项
1.2.2.1案例代码二:

package com.itheima_01;import java.io.FileWriter;
import java.io.IOException;/** 输出流写数据的步骤：*       A:创建输出流对象*      B:调用输出流对象的写数据方法，并刷新缓冲区*      C:释放资源* * 相对路径：相对当前项目而言的，在项目的根目录下(a.txt)* 绝对路径：以盘符开始的路径(d:\\a.txt)* * close()和flush()方法的区别：*        flush():刷新缓冲区。流对象还可以继续使用。*      close():先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。*/
public class FileWriterDemo2 {public static void main(String[] args) throws IOException {//创建输出流对象//FileWriter fw = new FileWriter("d:\\a.txt");FileWriter fw = new FileWriter("a.txt");//调用输出流对象的写数据方法，并刷新缓冲区fw.write("helloworld");fw.flush();fw.write("java");fw.flush();//释放资源fw.close();//Stream closed//fw.write("javaee");//fw.flush();}
}

1.2.3FileWriter其它写方法
void write(String str):写一个字符串数据
void write(String str,int index,int len):写一个字符串中的一部分数据
void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。‘a’,97
void write(char[] chs):写一个字符数组数据
void write(char[] chs,int index,int len):写一个字符数组的一部分数据
1.2.3.1案例代码三:

package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;/** void write(String str):写一个字符串数据* void write(String str,int index,int len):写一个字符串中的一部分数据* void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。'a',97* void write(char[] chs):写一个字符数组数据* void write(char[] chs,int index,int len):写一个字符数组的一部分数据*/
public class FileWriterDemo3 {public static void main(String[] args) throws IOException {//创建输出流对象FileWriter fw = new FileWriter("b.txt");//void write(String str):写一个字符串数据//fw.write("abcde");//void write(String str,int index,int len):写一个字符串中的一部分数据//fw.write("abcde",0,5);//fw.write("abcde",1,3);//void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。'a',97//fw.write('a');//fw.write(97);//void write(char[] chs):写一个字符数组数据char[] chs = {'a','b','c','d','e'};//fw.write(chs);//void write(char[] chs,int index,int len):写一个字符数组的一部分数据//fw.write(chs,0,5);fw.write(chs,2,3);//释放资源fw.close();}
}

1.2.4FileWriter写入换行以及向文本末尾追加
1.2.4.1案例代码四:

package com.itheima_01;import java.io.FileWriter;
import java.io.IOException;/** 如何实现数据的换行?*      \n可以实现换行，但是windows系统自带的记事本打开并没有换行，这是为什么呢?因为windows识别的换行不是\n，而是\r\n*        windows:\r\n*       linux:\n*       mac:\r* 如何实现数据的追加写入?*       FileWriter(String fileName, boolean append)*/
public class FileWriterDemo4 {public static void main(String[] args) throws IOException {//创建输出流对象//FileWriter fw = new FileWriter("c.txt");FileWriter fw = new FileWriter("c.txt",true); //表示追加写入，默认是falsefor(int x=0; x<10; x++) {fw.write("hello"+x);fw.write("\r\n");}//释放资源fw.close();}
}

 FileReader类使用
FileReader类使用

第2章FileReader类使用

2.1FileReader读数据一次读取一个字符
2.1.1案例代码五:

package com.itheima_02;
import java.io.FileReader;
import java.io.IOException;/** 需求：从文件中读数据并显示到控制台*        读数据--输入流--FileReader* * FileReader:*        FileReader(String fileName):传递文件名称* * 输入流读文件的步骤：*        A:创建输入流对象*      B:调用输入流对象的读数据方法*        C:释放资源* * java.io.FileNotFoundException: fr.txt (系统找不到指定的文件。)*/
public class FileReaderDemo {public static void main(String[] args) throws IOException {//创建输入流对象
//      FileReader fr = new FileReader("fr.txt");FileReader fr = new FileReader("FileWriterDemo.java");//调用输入流对象的读数据方法//int read():一次读取一个字符/*//第一次读数据int ch = fr.read();System.out.println(ch);System.out.println((char)ch);//第二次读数据ch = fr.read();System.out.println(ch);System.out.println((char)ch);//第三次读数据ch = fr.read();System.out.println(ch);System.out.println((char)ch);//这是时候，我们发现代码的重复度很高，想用循环改进，但是不知道循环的结束条件是什么ch = fr.read();System.out.println(ch);ch = fr.read();System.out.println(ch);//通过测试，我们知道，如果读取数据的返回值是-1的时候，就说明没有数据了，这也是我们循环的结束条件*/int ch;//1:fr.read()//2:ch=fr.read()//3:ch != -1while((ch=fr.read())!=-1) {//System.out.println(ch);//System.out.println((char)ch);System.out.print((char)ch);}//释放资源fr.close();}
}

2.2利用FileReader和FileWriter完成文件复制
2.2.1读一次写一次

2.2.1.1案例代码六:

package com.itheima_03;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;/** 需求：*      把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中* * 文件复制也是有规律可循的，也就是说有套路。* * 数据源：*       FileWriterDemo.java -- 读数据 -- FileReader* 目的地：*      Copy.java -- 写数据 -- FileWriter*/
public class CopyFileDemo {public static void main(String[] args) throws IOException {//创建输入流对象FileReader fr = new FileReader("FileWriterDemo.java");//创建输出流对象FileWriter fw = new FileWriter("Copy.java");//读写数据int ch;while((ch=fr.read())!=-1) {fw.write(ch);}//释放资源fw.close();fr.close();}
}

2.2.2利用字符数组拷贝文件

2.2.2.1案例代码七:

package com.itheima_03;import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;/** 需求：*      把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中* * 数据源：*       FileWriterDemo.java -- 读数据 -- FileReader* 目的地：*      Copy.java -- 写数据 -- FileWriter*/
public class CopyFileDemo2 {public static void main(String[] args) throws IOException {//创建输入流对象FileReader fr  = new FileReader("FileWriterDemo.java");//创建输出流对象FileWriter fw = new FileWriter("Copy.java");//读写数据char[] chs = new char[1024];int len;while((len=fr.read(chs))!=-1) {fw.write(chs, 0, len);}//释放资源fw.close();fr.close();}
}

2.2.3拷贝文件的两种方式图解

第3章缓冲流介绍和使用

3.1缓冲流的基本使用
3.1.1案例代码八:

package com.itheima_04;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;/** BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 * BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。*/
public class BufferedStreamDemo {public static void main(String[] args) throws IOException {//创建输出缓冲流对象/*BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));bw.write("hello");//bw.flush();bw.close();*///创建输入缓冲流对象BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));/*//一次读写一个字符int ch;while((ch=br.read())!=-1){System.out.print((char)ch);}*///一次读写一个字符数组char[] chs = new char[1024];int len;while((len=br.read(chs))!=-1) {System.out.print(new String(chs,0,len));}//释放资源br.close();}
}

3.2缓冲流复制文本文件的两种方式
利用缓冲流把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中
第一种方式:使用缓冲流不使用字符数组
第二种方式:使用缓冲流使用字符数组
3.2.1案例代码九:

package com.itheima_04;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;/** 需求：*      把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中* * 数据源：*       FileWriterDemo.java -- 读数据 -- FileReader -- 高效的读数据 -- BufferedReader* 目的地：*      Copy.java -- 写数据 -- FileWriter -- 高效的写数据 -- BufferedWriter*/
public class CopyFileDemo {public static void main(String[] args) throws IOException {//创建输入缓冲流对象BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));//创建输出缓冲流对象BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));//读写数据/*//一次读写一个字符int ch;while((ch=br.read())!=-1) {bw.write(ch);}*///一次读写一个字符数组char[] chs = new char[1024];int len;while((len=br.read(chs))!=-1) {bw.write(chs,0,len);}//释放资源bw.close();br.close();}
}

3.3缓冲流的特有方法使用
BufferedWriter
void newLine():写一个换行符，这个换行符由系统决定,不同的操作系统newLine()方法使用的换行符不同
windows:\r\n
linux:\n
mac:\r
BufferedReader
String readLine():一次读取一行数据，但是不读取换行符
3.3.1案例代码十:

package com.itheima_05;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;/** 缓冲流的特殊功能：* BufferedWriter*        void newLine():写一个换行符，这个换行符由系统决定* BufferedReader*        String readLine():一次读取一行数据，但是不读取换行符*/
public class BufferedStreamDemo {public static void main(String[] args) throws IOException {/*BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));for(int x=0; x<10; x++) {bw.write("hello"+x);//bw.write("\r\n");bw.newLine();bw.flush();}bw.close();*/BufferedReader br = new BufferedReader(new FileReader("br.txt"));/*String line = br.readLine();System.out.println(line);line = br.readLine();System.out.println(line);line = br.readLine();System.out.println(line);line = br.readLine();System.out.println(line);*/String line;//1:br.readLine()//2:line=br.readLine()//3:line != nullwhile((line=br.readLine())!=null) {System.out.println(line);}br.close();}
}

3.4缓冲流的特有方法复制文件
3.4.1案例代码十一:

package com.itheima_05;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/** 需求：*         把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中* * 数据源：*       FileWriterDemo.java -- 读数据 -- FileReader -- 高效的读数据 -- BufferedReader* 目的地：*      Copy.java -- 写数据 -- FileWriter -- 高效的写数据 -- BufferedWriter*/
public class CopyFileDemo {public static void main(String[] args) throws IOException {//创建输入缓冲流对象BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));//创建输出缓冲流对象BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));//读写数据String line;while((line=br.readLine())!=null) {bw.write(line);bw.newLine();bw.flush();}//释放资源bw.close();br.close();}
}

第4章IO流相关案例

4.1复制文本文件的5种方式
A:利用基本流一次读写一个字符
B:利用基本流一次读写一个字符数组
C:利用缓冲流一次读写一个字符
D:利用缓冲流一次读写一个字符数组
E:利用缓冲流的特有方法一次读写一个字符串
4.1.1案例代码十二:

package com.itheima_06;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;/** 复制文本文件(5种方式)* * 数据源：*         FileWriterDemo.java* 目的地：*       Copy.java*/
public class CopyFileTest {public static void main(String[] args) throws IOException {/*method1("FileWriterDemo.java","Copy.java");method2("FileWriterDemo.java","Copy.java");method3("FileWriterDemo.java","Copy.java");method4("FileWriterDemo.java","Copy.java");method5("FileWriterDemo.java","Copy.java");*/String srcFileName = "FileWriterDemo.java";String destFileName = "Copy.java";//      method1(srcFileName,destFileName);
//      method2(srcFileName,destFileName);method3(srcFileName,destFileName);
//      method4(srcFileName,destFileName);
//      method5(srcFileName,destFileName);}//缓冲流一次读写一个字符串public static void method5(String srcFileName,String destFileName) throws IOException {//创建输入缓冲流对象BufferedReader br = new BufferedReader(new FileReader(srcFileName));//创建输出缓冲流对象BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));//一次读写一个字符串String line;while((line=br.readLine())!=null){bw.write(line);bw.newLine();bw.flush();}//释放资源bw.close();br.close();}//缓冲流一次读写一个字符数组public static void method4(String srcFileName,String destFileName) throws IOException {//创建输入缓冲流对象BufferedReader br = new BufferedReader(new FileReader(srcFileName));//创建输出缓冲流对象BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));//一次读写一个字符数组char[] chs = new char[1024];int len;while((len=br.read(chs))!=-1) {bw.write(chs,0,len);}//释放资源bw.close();br.close();}//缓冲流一次读写一个字符public static void method3(String srcFileName,String destFileName) throws IOException {//创建输入缓冲流对象BufferedReader br = new BufferedReader(new FileReader(srcFileName));//创建输出缓冲流对象BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));//一次读写一个字符int ch;while((ch=br.read())!=-1) {bw.write(ch);}//释放资源bw.close();br.close();}//基本流一次读写一个字符数组public static void method2(String srcFileName,String destFileName) throws IOException {//创建输入流对象FileReader fr = new FileReader(srcFileName);//创建输出流对象FileWriter fw = new FileWriter(destFileName);//一次读写一个字符数组char[] chs = new char[1024];int len;while((len=fr.read(chs))!=-1) {fw.write(chs,0,len);}//释放资源fw.close();fr.close();}//基本流一次读写一个字符public static void method1(String srcFileName,String destFileName) throws IOException {//创建输入流对象FileReader fr = new FileReader(srcFileName);//创建输出流对象FileWriter fw = new FileWriter(destFileName);//一次读写一个字符int ch;while((ch=fr.read())!=-1) {fw.write(ch);}//释放资源fw.close();fr.close();}
}

4.2把集合中的数据写到文本文件
把ArrayList集合中的字符串数据存储到文本文件项目根目下的array.txt中
每一个字符串元素作为文件中的一行数据
4.2.1案例代码十三:

package com.itheima_06;import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;/** 把ArrayList集合中的字符串数据存储到文本文件* 每一个字符串元素作为文件中的一行数据* * 分析：*        A:创建集合对象*       B:往集合中添加字符串元素*      C:创建输出缓冲流对象*        D:遍历集合，得到每一个字符串元素，然后把该字符串元素作为数据写到文本文件*        E:释放资源*/
public class ArrayListToFileTest {public static void main(String[] args) throws IOException {//创建集合对象ArrayList<String> array = new ArrayList<String>();//往集合中添加字符串元素array.add("hello");array.add("world");array.add("java");//创建输出缓冲流对象BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));//遍历集合，得到每一个字符串元素，然后把该字符串元素作为数据写到文本文件for(int x=0; x<array.size(); x++) {String s = array.get(x);bw.write(s);bw.newLine();bw.flush();}//释放资源bw.close();}
}

4.3把文本文件中的数据读取到集合

从项目根目录下的array.txt文本文件中读取数据到ArrayList集合中，并遍历集合,每一行数据作为一个字符串元素
4.3.1案例代码十四:

package com.itheima_06;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;/** 从文本文件中读取数据到ArrayList集合中，并遍历集合* 每一行数据作为一个字符串元素* * 分析：*      A:创建输入缓冲流对象*        B:创建集合对象*       C:读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中*        D:释放资源*         E:遍历集合*/
public class FileToArrayListTest {public static void main(String[] args) throws IOException {//创建输入缓冲流对象BufferedReader br = new  BufferedReader(new FileReader("array.txt"));//创建集合对象ArrayList<String> array = new ArrayList<String>();//读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中String line;while((line=br.readLine())!=null) {array.add(line);}//释放资源br.close();//遍历集合for(int x=0; x<array.size(); x++) {String s = array.get(x);System.out.println(s);}}
}

笔记整理2----Java语言基础（二）06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础相关推荐

Java基础知识（三十一）IO流（二） File类、递归、IO流基础
目录一. File类 1.File: 2.构造方法: 3.创建功能 4.删除功能 5. 重命名功能 6.判断功能 7.基本获取功能 8.高级获取功能 9.需求: 二.递归 1.概述: 2. 递 ...
Java基础（二）:集合、IO流(Zip压缩输入/输出流等)、File文件类、反射、枚举
Java基础(一):编译和解释.数据类型.变量作用域.String常用方法.数组.面向对象.异常 Java基础(二):集合.IO流(Zip压缩输入/输出流等).File文件类.反射.枚举 Java异常 ...
java IO流基础万字详解（从拷贝文件到模拟上传头像）
目录一.前言: 二.IO流简介: 1.什么是IO流? 2.IO流能干什么? 3.IO流的分类: 4.IO流体系: 三.字符流读写文件: 1.普通字符流读取文件: 前言: ①以单个字符读取: 代码演示 ...
IO流---基础（附相对路径）
一.IO流-基础 (附相对路径) 概念: 参照物:内存.程序 Input: 输入从硬盘到程序/ 读取Reader Output: 输出从程序到硬盘/ Writer 流的派系类型注释 java. ...
java面向对象-类和对象
Java面向对象笔记文章目录 Java面向对象笔记 java面向对象类和对象什么是类定义创建和使用公式构造方法什么是构造方怎么定义和使用构造方法实列 This关键字什么是成员变量 ...
统一建模语言UML轻松入门（3）――静态建模：类和对象
统一建模语言UML轻松入门(3)――静态建模:类和对象 --------------------------------------------------------------------- 宋宝 ...
类与对象的演练好好学习的学生 java 1613807015
类与对象的演练好好学习的学生 java 1613807015 需求与分析代码实现定义学生类使用学生类运行结果
java语言入门(二)之JAVA的基本语法
*关键字和保留字 1.关键字(keyword)的定义和特点定义:被 Java 语言赋予了特殊含义,用做专门用途的字符串(单词) 特点:关键字中所有字母都为小写官方地址: https://docs. ...
【Groovy】Groovy 动态语言特性 ( Groovy 语言与 Java 语言执行效率对比 | 以动态特性编译的 Groovy 类 | 以静态特性编译的 Groovy 类 )
文章目录一.以动态特性编译的 Groovy 类二.Groovy 语言与 Java 语言执行效率对比三.以静态特性编译的 Groovy 类一.以动态特性编译的 Groovy 类 Groovy 类 ...

笔记整理2----Java语言基础（二）06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础

06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础

第06天 java基础语法

第1章 Eclipse断点调试

第2章基础语法的练习

第07天面向对象基础

第1章面向对象概述

第2章面向对象特性之封装

第3章面向对象之构造方法

第4章类名作为形参和返回值

第08天常用API

第1章 API概述

第2章 Scanner类与 String类

第3章 StringBuilder类

第09天 java集合

第1章对象数组

第2章集合类之ArrayList

第3章学生管理系统案例

第10天 IO

第1章IO流概述及FileWriter类使用

第2章FileReader类使用

第3章缓冲流介绍和使用

第4章IO流相关案例

笔记整理2----Java语言基础（二）06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础相关推荐

最新文章

热门文章

笔记整理2----Java语言基础（二）06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础

06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础

第06天 java基础语法

第1章 Eclipse断点调试

第2章 基础语法的练习

第07天 面向对象基础

第1章 面向对象概述

第2章 面向对象特性之封装

第3章 面向对象之构造方法

第4章 类名作为形参和返回值

第08天 常用API

第1章 API概述

第2章 Scanner类 与 String类

第3章 StringBuilder类

第09天 java集合

第1章对象数组

第2章集合类之ArrayList

第3章学生管理系统案例

第10天 IO

第1章IO流概述及FileWriter类使用

第2章FileReader类使用

第3章缓冲流介绍和使用

第4章IO流相关案例

笔记整理2----Java语言基础（二）06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础相关推荐

最新文章

热门文章

第2章基础语法的练习

第07天面向对象基础

第1章面向对象概述

第2章面向对象特性之封装

第3章面向对象之构造方法

第4章类名作为形参和返回值

第08天常用API

第2章 Scanner类与 String类