JavaISoCool

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

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];
		
		//初始化第一个月和第二个月的兔子对数c
		arr[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
		
		
		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); //null
		System.out.println("年龄："+s.age); //0
		System.out.println("----------");
		
		//给成员变量赋值
		s.name = "林青霞";
		s.age = 28;
		
		//再次输出成员变量的值
		System.out.println("姓名："+s.name); //林青霞
		System.out.println("年龄："+s.age); //28
		System.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);//null
		System.out.println("价格："+p.price);//0
		System.out.println("颜色："+p.color);//null
		System.out.println("------------");
		
		//给成员变量赋值
		p.brand = "锤子";
		p.price = 2999;
		p.color = "棕色";
		
		//再次输出成员变量值
		System.out.println("品牌："+p.brand);//锤子
		System.out.println("价格："+p.price);//2999
		System.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("---------");
		
		//方式4
		String 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)); //false
		
		String s3 = "hello";
		System.out.println("s1==s3:"+(s1==s3)); //false
		System.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();
		
		//定义三个统计变量，初始化值都是0
		int 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 -- StringBuilder
		String 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() -- String
		StringBuilder 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的地方我们使用引用数据类型替换即可
 * 			举例：ArrayList,ArrayList
 * 
 * 构造方法：
 * 		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 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 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
		
		//我们必须给出学号不存在的时候的提示
		
		//定义一个索引
		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); //表示追加写入，默认是false
		
		for(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 != -1
		while((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 != null
		while((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流-基础)

斤斤计较的婚姻到底有多难？白心之岂必有为
很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
随笔 | 仙一般的灵气海思沧海
仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
一百九十四章. 自相矛盾巨木擎天
唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
谢谢你们，爱你们！鹿游儿
昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
爬山后遗症璃绛
爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
《策划经理回忆录之二》路基雅虎
话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码说私域人工智能小程序
摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
向内而求陈陈_19b4
10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
2021-08-26 影幽
在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
高级编程--XML+socket练习题 masa010 java 开发语言
1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
2018-07-23-催眠日作业-#不一样的31天#-66小鹿小鹿_33
预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言 html javascript 前端 css css3
1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
《大清方方案》| 第二话谁佐清欢
和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
本周第二次约练 2cfbdfe28a51
中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
每日一题——第九十题互联网打工人no1 C语言程序设计每日一练 c语言
题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
2022-07-08 保利学府里李楚怡1307022
——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
iOS http封装 374016526 ios 服务器交互 http 网络请求
程序开发避免不了与服务器的交互，这里打包了一个自己写的http交互库。希望可以帮到大家。内置一个basehttp，当我们创建自己的service可以继承实现。 KuroAppBaseHttp *baseHttp = [[KuroAppBaseHttp alloc] init]; [baseHttp setDelegate:self]; [baseHttp
lolcat ：一个在 Linux 终端中输出彩虹特效的命令行工具 brotherlamp linux linux教程 linux视频 linux自学 linux资料
那些相信 Linux 命令行是单调无聊且没有任何乐趣的人们，你们错了，这里有一些有关 Linux 的文章，它们展示着 Linux 是如何的有趣和“淘气” 。在本文中，我将讨论一个名为“lolcat”的小工具 – 它可以在终端中生成彩虹般的颜色。何为 lolcat ? Lolcat 是一个针对 Linux，BSD 和 OSX 平台的工具，它类似于 cat 命令，并为 cat
MongoDB索引管理（1）——[九] eksliang mongodb MongoDB管理索引
转载请出自出处：http://eksliang.iteye.com/blog/2178427 一、概述数据库的索引与书籍的索引类似，有了索引就不需要翻转整本书。数据库的索引跟这个原理一样，首先在索引中找，在索引中找到条目以后，就可以直接跳转到目标文档的位置，从而使查询速度提高几个数据量级。不使用索引的查询称
Informatica参数及变量 18289753290 Informatica 参数变量
下面是本人通俗的理解，如有不对之处，希望指正 info参数的设置：在info中用到的参数都在server的专门的配置文件中（最好以parma）结尾下面的GLOBAl就是全局的，$开头的是系统级变量，$$开头的变量是自定义变量。如果是在session中或者mapping中用到的变量就是局部变量，那就把global换成对应的session或者mapping名字。 [GLOBAL] $Par
python 解析unicode字符串为utf8编码字符串酷的飞上天空 unicode
php返回的json字符串如果包含中文，则会被转换成\uxx格式的unicode编码字符串返回。在浏览器中能正常识别这种编码，但是后台程序却不能识别，直接输出显示的是\uxx的字符，并未进行转码。转换方式如下 >>> import json >>> q = '{"text":"\u4
Hibernate的总结永夜-极光 Hibernate
1.hibernate的作用,简化对数据库的编码,使开发人员不必再与复杂的sql语句打交道做项目大部分都需要用JAVA来链接数据库，比如你要做一个会员注册的页面，那么获取到用户填写的基本信后，你要把这些基本信息存入数据库对应的表中，不用hibernate还有mybatis之类的框架，都不用的话就得用JDBC，也就是JAVA自己的，用这个东西你要写很多的代码，比如保存注册信
SyntaxError: Non-UTF-8 code starting with '\xc4' 随便小屋 python
刚开始看一下Python语言，传说听强大的，但我感觉还是没Java强吧！写Hello World的时候就遇到一个问题，在Eclipse中写的，代码如下 ''' Created on 2014年10月27日 @author: Logic ''' print("Hello World!"); 运行结果 SyntaxError: Non-UTF-8
学会敬酒礼仪不做酒席菜鸟 aijuans 菜鸟
俗话说，酒是越喝越厚，但在酒桌上也有很多学问讲究，以下总结了一些酒桌上的你不得不注意的小细节。细节一：领导相互喝完才轮到自己敬酒。敬酒一定要站起来，双手举杯。细节二：可以多人敬一人，决不可一人敬多人，除非你是领导。细节三：自己敬别人，如果不碰杯，自己喝多少可视乎情况而定，比如对方酒量，对方喝酒态度，切不可比对方喝得少，要知道是自己敬人。细节四：自己敬别人，如果碰杯，一
《创新者的基因》读书笔记 aoyouzi 读书笔记《创新者的基因》
创新者的基因创新者的“基因”，即最具创意的企业家具备的五种“发现技能”：联想，观察，实验，发问，建立人脉。第一部分破坏性创新，从你开始第一章破坏性创新者的基因如何获得启示：发现以下的因素起到了催化剂的作用：(1) -个挑战现状的问题；(2)对某项技术、某个公司或顾客的观察；(3) -次尝试新鲜事物的经验或实验；(4)与某人进行了一次交谈，为他点醒
表单验证技术百合不是茶 JavaScript DOM对象 String对象事件
js最主要的功能就是验证表单,下面是我对表单验证的一些理解,贴出来与大家交流交流 ,数显我们要知道表单验证需要的技术点, String对象,事件,函数一:String对象;通常是对字符串的操作; 1,String的属性; 字符串.length;表示该字符串的长度; var str= "java"
web.xml配置详解之context-param bijian1013 java servlet web.xml context-param
一.格式定义： <context-param> <param-name>contextConfigLocation</param-name> <param-value>contextConfigLocationValue></param-value> </context-param> 作用：该元
Web系统常见编码漏洞（开发工程师知晓） Bill_chen sql PHP Web fckeditor 脚本
1.头号大敌：SQL Injection 原因：程序中对用户输入检查不严格，用户可以提交一段数据库查询代码，根据程序返回的结果，获得某些他想得知的数据，这就是所谓的SQL Injection，即SQL注入。本质: 对于输入检查不充分，导致SQL语句将用户提交的非法数据当作语句的一部分来执行。示例： String query = "SELECT id FROM users
【MongoDB学习笔记六】MongoDB修改器 bit1129 mongodb
本文首先介绍下MongoDB的基本的增删改查操作，然后，详细介绍MongoDB提供的修改器，以完成各种各样的文档更新操作 MongoDB的主要操作 show dbs 显示当前用户能看到哪些数据库 use foobar 将数据库切换到foobar show collections 显示当前数据库有哪些集合 db.people.update，update不带参数，可
提高职业素养，做好人生规划白糖_ 人生
培训讲师是成都著名的企业培训讲师，他在讲课中提出的一些观点很新颖，在此我收录了一些分享一下。注：讲师的观点不代表本人的观点，这些东西大家自己揣摩。 1、什么是职业规划：职业规划并不完全代表你到什么阶段要当什么官要拿多少钱，这些都只是梦想。职业规划是清楚的认识自己现在缺什么，这个阶段该学习什么，下个阶段缺什么，又应该怎么去规划学习，这样才算是规划。
国外的网站你都到哪边看？ bozch 技术网站国外
学习软件开发技术，如果没有什么英文基础，最好还是看国内的一些技术网站，例如：开源OSchina，csdn，iteye,51cto等等。个人感觉如果英语基础能力不错的话，可以浏览国外的网站来进行软件技术基础的学习，例如java开发中常用的到的网站有apache.org 里面有apache的很多Projects,springframework.org是spring相关的项目网站,还有几个感觉不错的
编程之美-光影切割问题 bylijinnan 编程之美
package a; public class DisorderCount { /**《编程之美》“光影切割问题” * 主要是两个问题： * 1.数学公式（设定没有三条以上的直线交于同一点）： * 两条直线最多一个交点，将平面分成了4个区域； * 三条直线最多三个交点，将平面分成了7个区域； * 可以推出：N条直线 M个交点，区域数为N+M+1。
关于Web跨站执行脚本概念 chenbowen00 Web 安全跨站执行脚本
跨站脚本攻击(XSS)是web应用程序中最危险和最常见的安全漏洞之一。安全研究人员发现这个漏洞在最受欢迎的网站,包括谷歌、Facebook、亚马逊、PayPal,和许多其他网站。如果你看看bug赏金计划,大多数报告的问题属于 XSS。为了防止跨站脚本攻击,浏览器也有自己的过滤器,但安全研究人员总是想方设法绕过这些过滤器。这个漏洞是通常用于执行cookie窃取、恶意软件传播,会话劫持,恶意重定向。在
[开源项目与投资]投资开源项目之前需要统计该项目已有的用户数 comsci 开源项目
现在国内和国外,特别是美国那边,突然出现很多开源项目,但是这些项目的用户有多少,有多少忠诚的粉丝,对于投资者来讲,完全是一个未知数,那么要投资开源项目,我们投资者必须准确无误的知道该项目的全部情况,包括项目发起人的情况,项目的维持时间..项目的技术水平,项目的参与者的势力,项目投入产出的效益.....
oracle alert log file（告警日志文件） daizj oracle 告警日志文件 alert log file
The alert log is a chronological log of messages and errors, and includes the following items: All internal errors (ORA-00600), block corruption errors (ORA-01578), and deadlock errors (ORA-00060)
关于 CAS SSO 文章声明 denger SSO
由于几年前写了几篇 CAS 系列的文章，之后陆续有人参照文章去实现，可都遇到了各种问题，同时经常或多或少的收到不少人的求助。现在这时特此说明几点： 1. 那些文章发表于好几年前了，CAS 已经更新几个很多版本了，由于近年已经没有做该领域方面的事情，所有文章也没有持续更新。 2. 文章只是提供思路，尽管 CAS 版本已经发生变化，但原理和流程仍然一致。最重要的是明白原理，然后
初二上学期难记单词 dcj3sjt126com english word
lesson 课 traffic 交通 matter 要紧；事物 happy 快乐的，幸福的 second 第二的 idea 主意；想法；意见 mean 意味着 important 重要的，重大的 never 从来，决不 afraid 害怕的 fifth 第五的 hometown 故乡，家乡 discuss 讨论；议论 east 东方的 agree 同意；赞成 bo
uicollectionview 纯代码布局, 添加头部视图 dcj3sjt126com Collection
#import <UIKit/UIKit.h> @interface myHeadView : UICollectionReusableView { UILabel *TitleLable; } -(void)setTextTitle; @end #import "myHeadView.h" @implementation m
N 位随机数字串的 JAVA 生成实现 FX夜归人 java Math 随机数 Random
/** * 功能描述随机数工具类<br /> * @author FengXueYeGuiRen * 创建时间 2014-7-25<br /> */ public class RandomUtil { // 随机数生成器 private static java.util.Random random = new java.util.R
Ehcache（09）——缓存Web页面 234390216 ehcache 页面缓存
页面缓存目录 1 SimplePageCachingFilter 1.1 calculateKey 1.2 可配置的初始化参数 1.2.1 cach
spring中少用的注解@primary解析 jackyrong primary
这次看下spring中少见的注解@primary注解，例子 @Component public class MetalSinger implements Singer{ @Override public String sing(String lyrics) { return "I am singing with DIO voice
Java几款性能分析工具的对比 lbwahoo java
Java几款性能分析工具的对比摘自：http://my.oschina.net/liux/blog/51800 在给客户的应用程序维护的过程中，我注意到在高负载下的一些性能问题。理论上，增加对应用程序的负载会使性能等比率的下降。然而，我认为性能下降的比率远远高于负载的增加。我也发现，性能可以通过改变应用程序的逻辑来提升，甚至达到极限。为了更详细的了解这一点，我们需要做一些性能
JVM参数配置大全 nickys jvm 应用服务器
JVM参数配置大全 /usr/local/jdk/bin/java -Dresin.home=/usr/local/resin -server -Xms1800M -Xmx1800M -Xmn300M -Xss512K -XX:PermSize=300M -XX:MaxPermSize=300M -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=5 -
搭建 CentOS 6 服务器(14) - squid、Varnish rensanning varnish
（一）squid 安装 # yum install httpd-tools -y # htpasswd -c -b /etc/squid/passwords squiduser 123456 # yum install squid -y 设置 # cp /etc/squid/squid.conf /etc/squid/squid.conf.bak # vi /etc/
Spring缓存注解@Cache使用 tom_seed spring
参考资料 http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/ http://swiftlet.net/archives/774 缓存注解有以下三个： @Cacheable @CacheEvict @CachePut
dom4j解析XML时出现"java.lang.noclassdeffounderror: org/jaxen/jaxenexception"错误 xp9802
java.lang.NoClassDefFoundError: org/jaxen/JaxenExc 关键字: java.lang.noclassdeffounderror: org/jaxen/jaxenexception 使用dom4j解析XML时，要快速获取某个节点的数据，使用XPath是个不错的方法，dom4j的快速手册里也建议使用这种方式执行时却抛出以下异常： Exceptio