[Java视频笔记]day18

类 System: 类中的方法和属性都是静态的。

out: 代表标准输出，默认是控制台。

in: 标准输入，默认是键盘。

描述系统的一些信息。

获取系统属性信息：Properties getProperties();

import java.util.*;

class  day18
{
	public static void main(String[] args)
	{
		Properties prop = System.getProperties();

		//因为Properties是HashTable的子类，也就是Map中的一个子类对象。
		//那么可以通过map的方法取出该集合中的元素。
		//该集合存储的都是字符串，没有泛型定义

		//如何在系统中自定义一些特有信息呢？
		System.setProperty("mykey", "myvalue");

		//获取指定属性信息
		String value = System.getProperty("os.name");
		System.out.println(value);

		String v = System.getProperty("haha");
		System.out.println(v);//输出null

		//可不可以在jvm启动时，动态加载一些属性信息呢？
		//在控制台输入java -Dhaha-qq day18就可以添加一些信息
		System.out.println(v);//输入后 这时输出qq

		//获取所有属性信息
		for(Object obj : prop.keySet())
		{
			String value = (String)prop.get(obj);
			System.out.println(obj + "..."+value);
		}

	}
}

Runtime类

该类并没有提供构造函数，说明不可以new对象，那么会直接想到该类中的方法都是静态的。发现该类中还有非静态方法。说明该类肯定会提供一个方法获取本类对象。而且该方法是静态的，并且返回值类型是本类类型。由这个特点可以看出该类使用了单例设计模式。

该方法是static Runtime getRuntime();

import java.util.*;

class  day18
{
	public static void main(String[] args) throws Exception
	{
		Runtime r = Runtime.getRuntime();
		Process p = r.exec("C:\\Windows\\System32\\calc.exe");//打开电脑系统程序"计算器"
		//Process p = r.exec("C:\\Windows\\System32\\notepad.exe day18.java");
		//打开记事本应用程序，并在记事本中打开day18.java这个文件
		//p.destroy();//进程杀掉

	}
	public static void sop(String obj)
	{
		System.out.println(obj);
	}
}

Date类

import java.util.*;
import java.text.*;

class  day18
{
	public static void main(String[] args) throws Exception
	{
		Date d = new Date();
		sop(d);//输出Fri May 06 15:44:07 CST 2016

		//将模式封装到SimpleDateFormat对象中
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日  hh:mm:ss");

		//调用format方法让模式格式化指定Date对象
		String time = sdf.format(d);

		sop(time);//输出 2016年05月06日  04:00:28
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

Calendar类

import java.util.*;
import java.text.*;

class  day18
{
	public static void main(String[] args) throws Exception
	{
		Calendar c = Calendar.getInstance();

		String[] mons = {"一月","二月","三月","四月"
		,"五月","六月","七月","八月"
		,"九月","十月","十一月","十二月"};

		//因为西方星期天是一星期的第一天，这里用查表法转成我们习惯的格式
		String[] weeks = {"","星期天","星期一","星期二","星期三","星期四",
			"星期五","星期六"};
		int index = c.get(Calendar.MONTH);
		int index1 = c.get(Calendar.DAY_OF_WEEK);

		sop(c.get(Calendar.YEAR)+"年");
		//sop((c.get(Calendar.MONTH) + 1) + "月");
		sop(mons[index]);
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");
		//sop("星期"+c.get(Calendar.DAY_OF_WEEK));
		sop(weeks[index1]);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

输出：

2016年

五月

6日

星期五

改变日期：

import java.util.*;
import java.text.*;

class  day18
{
	public static void main(String[] args) throws Exception
	{
		Calendar c = Calendar.getInstance();
		//c.set(2012, 2, 23);//2代表3月， 0代表1月
		c.add(Calendar.YEAR, 4);//年份+4
		printCalendar(c);
	}

	public static void printCalendar(Calendar c)
	{
		String[] mons = {"一月","二月","三月","四月"
		,"五月","六月","七月","八月"
		,"九月","十月","十一月","十二月"};

		//因为西方星期天是一星期的第一天，这里用查表法转成我们习惯的格式
		String[] weeks = {"","星期天","星期一","星期二","星期三","星期四",
			"星期五","星期六"};
		int index = c.get(Calendar.MONTH);
		int index1 = c.get(Calendar.DAY_OF_WEEK);

		sop(c.get(Calendar.YEAR)+"年");
		//sop((c.get(Calendar.MONTH) + 1) + "月");
		sop(mons[index]);
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");
		//sop("星期"+c.get(Calendar.DAY_OF_WEEK));
		sop(weeks[index1]);
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

/*
两个练习:
1.获取任意年的二月有多少天
思路：根据指定年设置一个时间
c.set(year, 2, 1);//某一年的3月1日
c.add(Calendar.DAY_OF_MONTH, -1);//3月1日往前推一天，就是2月最后一天
2.获取昨天的现在这个时刻
c.add(Calendar.DAY_OF_MONTH, -1);
*/

Math类

ceil()返回大于指定数据的最小整数

floor()返回小于指定数据的最大整数

round()返回四舍五入后的整数

pow(a, b) 返回a的b次方

random()随机数 大于等于0.0小于1.0的伪随机数

import java.util.*;
import java.text.*;

class  day18
{
	public static void main(String[] args) throws Exception
	{
		for(int x = 0; x < 10; x ++)
		{
			//double d = Math.random();//0到1
			int d = (int)(Math.random()* 10 + 1);//1到10的随机整数，包含10
			sop(d);
		}

		//另一种写法
		Random r = new Random();
		for(int x =0; x < 10; x ++)
		{
			int d = r.nextInt(10) + 1;//1到10的随机整数，包含10
			sop(d);
		}
	}

	public static void base()
	{
		double d = Math.ceil(3.6);
		sop(d);//输出4.0
		d = Math.ceil(-3.6);
		sop(d);//输出-3.0

		d = Math.floor(3.6);
		sop(d);//输出3.0
		d = Math.floor(-3.6);
		sop(d);//输出-4.0

		long l = Math.round(12.34);
		sop(l);//输出12
		l = Math.round(12.54);
		sop(l);//输出13

		sop(Math.pow(2, 3));//输出8.0
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

IO（Input Output）流

1. IO流用来处理设备之间的数据传输

2. Java对数据的操作是通过流的方式

3. Java用于操作流的对象都在IO包中

4. 流按操作数据分为两种：字节流和字符流。

5. 流按流向分为：输入流，输出流。

字节流的抽象基类

InputStream OutputStream

字符流的抽象基类

Reader Writer

由这四个类派生出来的子类名称都是以其父类作为子类名的后缀。

如: InputStream的子类FileInputStream

如: Reader的子类FileReader

先学习字符流的特点。

既然IO流是用于操作数据的。那么数据的最常见体现形式是：文件。先以操作文件为主来演示。

需求：在硬盘上，创建一个文件并写入一些文字数据。

找到一个专门用于操作文件的Writer子类对象，FileWriter.后缀名是父类名，前缀名是该流对象的功能。

import java.io.*;

class  day18
{
	public static void main(String[] args) throws IOException
	{
		//创建一个FileWriter对象，该对象一被初始化就必须要明确
		//被操作的文件,而且文件会被创建到指定目录下。如果该目录下
		//已有同名文件，将被覆盖。其实该步就是在明确数据存放的位置。
		FileWriter fw = new FileWriter("demo.txt");

		//调用write方法，将字符串写入到流中
		fw.write("abcde");

		//刷新流对象中的缓冲中的数据，将数据刷到目的地中
		fw.flush();

		//关闭流资源，但是关闭之间会刷新一次内部的缓冲中的数据
		//将数据刷到目的地中
		//和flush的区别：flush()刷新后流可以继续使用，close刷新后
		//将流关闭
		fw.close();

	}

}

IO异常的处理方式。

import java.io.*;

class  day18
{
	public static void main(String[] args)
	{
		FileWriter fw = null;
		try
		{
			fw = new FileWriter("demo.txt");

			fw.write("abdfd");
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}
		finally//里面一定得关闭,而且判断fw是否建立对象
		{
			try
			{
				if(fw != null)
					fw.close();
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
		}

	}

}

对已有文件的数据续写。

import java.io.*;

class  day18
{
	public static void main(String[] args) throws IOException
	{
		//传递一个true参数，代表不覆盖已有的文件，并在已有文件的
		//末尾处进行数据的续写。
		FileWriter fw = new FileWriter("demo.txt", true);

		fw.write("haha");

		fw.write("nihao\r\nxiexie");//在Windows里面\r\n代表换行
		//在Linux里面只写\n就可以

		fw.close();

	}

}

文本文件读取方式一：

import java.io.*;

class  day18
{
	public static void main(String[] args) throws IOException
	{
		//创建一个文件读取流对象，和指定名称的文件相关联
		//要保证该文件是已经存在的，如果不存在，发生异常FileNotFoundException
		FileReader fr  = new FileReader("demo.txt");

		//调用读取流对象的read方法
		//read()方法一次读一个字符，而且会自动往下读。

		int ch = fr.read();
		sop((char)ch);

		ch = fr.read();
		sop((char)ch);
		fr.close();

		ch = fr.read();//如果等于-1，则表示读完了

		/*
		while(true)
		{
			int ch = fr.read();
			if(ch == -1)
				break;
			sop((char)ch);
		}
		*/
		int ch = 0;
		while((ch = fr.read()) != -1)
		{
			sop((char)ch);
		}

	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

文本文件读取方式二：

通过字符数组进行读取。

import java.io.*;

class  day18
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr  = new FileReader("demo.txt");

		//定义一个字符数组，用于存储读到的字符。
		//该read(char[])方法返回的是读到的字符个数
		char[] buf = new char[1024];

		int num = 0;
		while((num =fr.read(buf)) != -1)
		{
			sop(new String(buf, 0, num));
			//从0开始打印，每次读出来num个，就打印num个
		}
		fr.close();

	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

练习：

读取一个.java文件，并打印在控制台上.

import java.io.*;

class  day18
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr  = new FileReader("demo.txt");

		char[] buf = new char[1024];

		int num = 0;
		while((num =fr.read(buf)) != -1)
		{
			System.out.print(new String(buf, 0, num));
		}
		fr.close();
	}

}

拷贝文本文件

将C盘一个文本文件复制到D盘。

复制的原理：

其实就是将C盘下的数据存储到D盘的一个文件中。

步骤：

1.在D盘创建一个文件，用于存储文件中的数据。

2.定义读取流和C盘文件关联。

3.通过不断的读写完成数据存储。

4.关闭资源

import java.io.*;

class  day18
{
	public static void main(String[] args) throws IOException
	{
		copy_2();
	}

	public static void copy_2()
	{
		FileWriter fw = null;
		FileReader fr = null;
		try
		{
			fw = new FileWriter("demo_copy2.txt");
			fr = new FileReader("demo.txt");
			char[] buf = new char[1024];
			int len = 0;
			while((len = fr.read(buf)) != -1)
			{
				fw.write(buf, 0, len);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("读写失败");
		}
		finally
		{
			if(fw != null)
				try
				{
					fw.close();
				}
				catch (IOException e)
				{
				}
			if(fr != null)
				try
				{
					fr.close();
				}
				catch (IOException e)
				{
				}
		}
	}

	//从C盘读一个字符，就往D盘写一个字符
	public static void copy_1() throws IOException
	{
		//创建目的地
		FileWriter fw = new FileWriter("demo_copy.txt");

		//与已有文件关联
		FileReader fr = new FileReader("demo.txt");

		int ch = 0;
		while((ch = fr.read()) != -1)
		{
			fw.write(ch);
		}
		fw.close();
		fr.close();
	}

}

时间： 2024-10-27 13:09:51

[Java视频笔记]day18的相关文章

传z播客 刘意_2015年Java基础视频笔记(day18~)(2016年3月7日00:25:16)

day18 1.Map引入 Map是区分于Collection的另外一个"老大" 作为学生来说,是根据学号来区分不同的学生的,那么假设我现在已经知道了学生的学号,我要根据学号去获取学生姓名,请问怎么做呢? 如果采用前面讲解过的集合,我们只能把学号和学生姓名作为一个对象的成员,然后存储整个对象,将来遍历的时候,判断,获取对应的名称. 但是呢,如果我都能把学生姓名拿出来了,我还需要根据编号去找吗? 针对我们目前的这种需求:仅仅知道学号,就想知道学生姓名的情况,Java就提供了一种新的集合 

一名测试初学者听JAVA视频笔记（一）

搭建pho开发环境与框架图 韩顺平 第一章: No1  关于文件以及文件夹的管理 将生成的文本文档做成详细信息的形式,显示文件修改时间以及文件大小,便于文件查看和管理,也是对于一名IT人士高效能工作的专业素养要求.如下图所示: 为了方便Java文件能够及时正确的找到,需要对电脑进行环境配置,要注意一下四个问题: 1.在硬盘中对所有文件夹进行管理,全部设置.点击,工具 > 查看 2.勾选显示文件及所有文件夹 3.去掉隐藏已知文件拓展名,防止出现类如 xxx .java.java 4.显示文件的完全

[Java视频笔记]day23

网络编程 网络模型:OSI参考模型,TCP/IP参考模型 网络通讯要素:IP地址,端口号,传输协议 IP地址(对应对象 InetAddress) 网络中设备的标识 不易记忆,可用主机名 本地回环地址:127.0.0.1主机名:localhost import java.net.*; class day23 { public static void main(String[] args) throws Exception { InetAddress i = InetAddress.getLocal

[Java视频笔记]day16

集合Map: 该集合存储键值对,一对一对往里存,而且要保证键的唯一性. 1.添加 put(Kkey, V value) putAll(Map<?extends K,? extends V> m) 2.删除 clear() remove(Object key) 3.判断 containsValue(Object value) containsKey(Object key) isEmpty() 4.获取 get(Objectkey) size() values() entrySet()  返回此映

[Java视频笔记]day14

为什么出现集合类? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式. 数组和集合类同是容器,有何不同? 数组虽然也可以存储对象,但长度是固定的,集合长度是可变的.数组中可以存储基本对象类型,集合只能存储对象,对象可以不同. 1. add方法的参数类型是Object,以便于接收任意类型对象. 2. 集合中存储的都是对象的引用(地址) 什么是迭代器呢? 其实就是集合的取出元素的方式. 共性方法代码: import java.

[Java视频笔记]day19

字符流的缓冲区 1. 缓冲区的出现提高了对数据的读写效率. 2. 对应类 BufferedWriter BufferedReader 3. 缓冲区要结合流才可以使用 4. 在流的基础上对流的功能进行了增强 缓冲区的出现是为了提高流的操作效率而出现的.所以在创建缓冲区之前,必须要先有流对象. 该缓冲区中提供了一个跨平台的换行符,newLine()方法. BufferedWriter import java.io.*; class day19 { public static void main(St

[Java视频笔记]day21

操作对象 ObjectInputStream ObjectOutputStream 被操作的对象需要实现Serializable(标记接口,没有方法的接口通常称为标记接口) 把对象存到硬盘上,叫做对象的持久化. 一般情况: import java.io.*; class Person implements Serializable { String name; int age; Person(String name, int age) { this.name = name; this.age =

[Java视频笔记]day20

File类 1. 用来将文件或者文件夹封装成对象 2. 方便对文件与文件夹的属性信息进行操作(流只能操作数据) 3. File对象可以作为参数传递给流的构造函数 File类常见方法: 1. 创建 boolean createNewFile();在指定位置创建文件,如果该文件已经存在,则不创建,返回false.和输出流不一样,输出流对象一建立就创建文件,而且文件已经存在,则覆            盖. boolean mkdir():创建文件夹 boolean mkdirs():创建多级文件夹

[java] 视频笔记

1 命名规则 class命名:第一个字母大写 变量命名:第一个字母小写 包命名:第一个字母小写 2 方法本质:实现方法的复用 3 类是对象的一个模板,对象是类的实例化. 对象也就是实例(Object    instance) 属性也就是成员变量 4 作为面向对象的思维来说,当你考虑一个问题时,不应该考虑第一步该干嘛,第二步该干嘛,这个是面向过程的编程思维,而应该考虑: (1)考虑问题有哪些类和对象: (2)这些类和对象有哪些属性和方法: (3)这些类(对象)之间的关系是什么. 类(对象)之间的关