来源: 互联网  发布时间: 2014-02-18

activity切换动画

 

在介绍切换动画效果前，先介绍下将使用到的Android SDK提供的工具类。

AlphaAnimation：控制动画对象的透明度，淡入淡出效果实现。

TranslateAnimation：控制动画对象的位置，实现对象位置的移动动画。

Animation：动画抽象类。

AnimationUtils：提供了动画的一些常用方法。

通过XML方式定义动画的形式。

更多的动画说明文档请看：http://android.toolib.net/guide/topics/resources/animation-resource.html

 

 

一、淡入淡出方式切换

1、建立Activity淡入动画的XML描述enter_alpha.xml

 

2、建立Activity淡出动画的XML描述out_alpha.xml

 

 

上述的xml文件存放路径，在res路径下新建文件夹anim，存放在此文件夹下。

 

在JAVA中调用动画资源方式：R.anmi.文件名

在XML中：@[package:]anim/文件名

 

3、设计主Activity界面main.xml

原型图效果：

界面XML描述：

 

 

打开MainActivity定义“淡入淡出Activity”按钮的change事件：

 

 

4、设计第二个Activity界面other.xml，并添加Activity信息到AndroidManifest.xml

原型图效果：

 

创建第二个Activity界面OtherActivity类：

 

添加Activity信息：

<activity android:name=".OtherActivity" android:label="otherActivity">

界面XML描述：

 

 

到这里，淡入淡出切换Activity已经完成。

 

二、滚动方式切换

在实现淡入淡出时，界面已经设计完成，这里只需要实现动画部分。

1、Activity滚入XML动画描述lefttoright.xml：

 

2、Activity滚出XML动画描述righttoleft.xml：

 

 

3、MainActivity中定义“滚动切换Activity”按钮事件

public void change2(View v){  

    Intent intent = new Intent(this, OtherActivity.class);  

      

    startActivity(intent);  

      

    overridePendingTransition(R.anim.lefttoright, R.anim.righttoleft);  

}  

 

 

    

    来源: 互联网  发布时间: 2014-02-18

Java复习篇五
从天津转站北京，爬到中关村到直立行走
Java复习篇五
IO流
IO流用于操作数据的，最常见形式是：文件。
字节流的抽象基类：InputStream,OutputStream
字符流的抽象基类：Reader,writer

FileReader创建一个文件读取流对象，和指定名称的文件相关联
对象存放在堆栈内存当中，将堆内存对象存放在硬盘上。
对象的持久化，可序列化。
静态是不能序列化。

源设备：键盘system.in ,硬盘，FileStream,内存ArrayStream
目的设备：控制台System.out,硬盘，FileStream,内存ArrayStream

Node节点:
数据来源（source）——>程序（数据输入流）
数据目的地(sink)<——程序（输出流）

IO包中，字节类别3种节点数
字符类4种节点数

种类、类别 字节 字符
FileInputStream FileReader
文件（file）  FileOutputStream FileWriter
ByteArrayInputStream CharArrayReader
内存(数组） ByteArrayOutputStream CahrArrayWriter
StringReader
内存（字符串） StringWriter

管道（pipe）PipeinputStream pipeReader
pipeOutputStream     PipeWriter

package com.blackhorse.io;
import java.io.*;

/**
*
* @author xinglefly
* @version 1
*/
public class IO1 {
/*
* 将一个文件文本中数据存储到另一个文件中，复制文件。
源：因为是源，所以使用读取流。InputStream Reader
是不是操作文本文件
是！这是可以选择Reader
这样体系就明确了。
接下来明确要使用该体系中的哪个对象。
明确设备：硬盘。上一个文件。
Reader体系中可以操作文件的对象是FileReader.
是否需要提高效率：是！加入Reader体系中缓冲区BufferedReader

FileReader fr = new FileReader("a.txt");
BufferedReader bufr = new BufferedReader(fr);

目的：OutputStream Writer
是否是纯文本。
是，writer.
设备：硬盘，一个文件。Writer体系中更可以操作文件的对象FileWriter.
是否需要提高效率：是！加入Writer体系中缓冲区BufferedWriter
FileWriter fw = new FileWriter("b.txt");
BufferedWriter bufw = new BufferedWriter(fw);
练习:将一个图片文件中数据存储到另一个文件中。复制文件。要按照以上格式自己完成三个明确。
*/


/*
* 1.源：键盘录入：
* 目的：控制台。
* 2.需求：想把键盘录入的数据存储到一个文件中。
* 源：键盘。
* 目的：文件。
*
* 3.需求:想要将一个文件的数据打印在控制台上。
* 源：文件。
* 目的：控制台。
*
* 流操作的基本规律：
* 最痛苦的就是流对象有很多，不知道该用哪一个。
*
* 通过三个明确来完成。
* 1.明确源和目的。
* 源：输入流。OutputStream Reader
* 目的：输出流.OutputStream Writer
* 2.操作的数据是否是纯文本。
* 是：字符流
* 不是：字节流。
* 3.当体系明确后，在明确要使用哪个具体的对象。
*  通过设备来进行区分：
*  源设备：内存，硬盘。键盘
*  目的设备：内存，硬盘，控制台。
*/

/*那么分别分析
* 源：InputStream Reader
* 是不是纯文本？是！Reader
*
* 设备：键盘。对应的对新啊格式System.in.
* 不是选择Reader吗？System.in对应的ushi字节流吗？
* 为了操作键盘的文本数据方便。转成字符流uanzhao字符串操作是最方便的。
* 所以既然明确Reader,那么就将System.in转换成Reader.
* 用了Reader体系中转换流，InputStreamReader
*
* InputStreamReader isr = new InputStreamReader(System.in);
* 需要提高效率吗？需要！BufferedReader
* BufferedReader bufr = new BufferedReader(isr);
*
* 目的：OutputStream Writer
* 是否是存文本。使用FileWriter.
* FileWriter fw = new FileWriter("c.txt");
* 需要提高效率吗?需要。
* BufferedWriter bufw = new BufferedWriter(fw);
*/

/**扩展一下，想要把录入的数据按照指定的编码表（utf-8）,将数据存在文件中。
* 目的：OutputStream Writer
* 是否是存文本？是！Writer
* 设备：硬盘。一个问价。使用FileWriter.
* 但是FileWriter是使用的默认编码表。GBK
*
* 但是存储时，需要加入指定编码表utf-8.而知道那个的编码表只有转换流可以指定。
* 所以要使用的对象是OutputStreamWriter.
* 而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream
* OutputStreamWriter osw = new OutputStreamWriter(new FileOutputstream("d.txt","uft-8"));
*
* 需要高效吗？需要
* BufferedWriter bufw = new BufferedWriter(ows);
* 所以，记住。转换流什么使用。字符和字节之间的桥梁，通常涉及字符编码转换时，需要用到转换流。
*
*
*练习：将一个文本数据打印在控制台上。要按照以上格式自己完成三个明确。
* @throws IOException
*/

public static void main(String[] args) throws IOException{

// System.setIn(new FileInputStream("c:\\MyMenuDemo.java"));
System.setOut(new PrintStream("c:\\zzz.txt"));

//键盘最常见写法。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

String line = null;
while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}

}
/**
* IO
* @author xinglefly
* @version 1
*/
/*
* 字节流和字符流
* 字节流两个基类
* InputStream(读) OutputStream（写）
* 字符流两个基类
* Reader Writer
* 先学习一下字符流的特点
* 既然IO流是用于操作数据的，那么数据的最常见体现是：文件
* 那么先以操作文件为主来演示
* 要求：在硬盘上，创建一个文件并写入一些文字数据。
* 找到一个专门用于操作文件的Writer子类对象。FileWriter.后缀名是父类名，前缀名是该流对象的功能。
*/
public class FileWriterDemo {
/*public static void main(String[] args)throws IOException{
//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
//而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
//其实该步就是在明确数据要存放的目的地。
FileWriter fw = new FileWriter("c:\\demo.txt");

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

//刷新流对行啊中的缓冲中的数据
//将数据刷到目的地中
// fw.flush();
fw.write("hahah");

//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据
//将数据刷到目的地中。
//和flush区别：flush刷新后，流可以继续使用，close舒心后，会将流关闭
fw.close();
}*/
public static void main(String[] args1){
FileWriter fw = null;
try{
fw = new FileWriter("c:\\demos.txt",true);
fw.write("abdejifejljiajfldjfieut\r\n jfjialfjdie");
fw.write("Tanks");
System.out.println(fw);
}catch(IOException e){
e.printStackTrace();
}finally{
if(fw!=null)
try {
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
}

缓冲区
import java.io.*;
/**
* BufferWriter
* 缓冲区的出现是为了提高流的操作效率出现的。
* 所以在创建缓冲区之前，必须要先有流对象。
* 该缓冲区中提供了一个跨平台的换行符。
* newline();
* @author xinglefly
* @version 1
*/
public class BufferWriterDemo {
public static void main(String[] args)throws IOException{
//创建一个字符写入流对象。
FileWriter fw = new FileWriter("c:\\ppt.txt");
//为了提高字符写入流效率。假如缓冲技术。
//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
BufferedWriter bufw = new BufferedWriter(fw);
for(int i=0;i<5;i++){
bufw.write("abcddfefe");
bufw.newLine();
}
//记住，只要用到缓冲区，酒啊要记得刷新。
// bufw.flush();
bufw.close();
}
}

/**
* BufferedReader类中特有方法readline的原理后，可以自定义一个类中包含一个功能和readline一致的方法
* 来模拟一下BufferedReader
* @author xinglefly
* @version 1
*/

public class MyBufferedReader {
private FileReader r;
MyBufferedReader(FileReader r){
this.r=r;
}
//可以一次读一行数据的方法。
public String myReadLine()throws IOException{
//定义一个临时容器，原BufferReader封装的是字符数组。
//为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
StringBuilder sb = new StringBuilder();
int ch=0;
while((ch=r.read())!=-1){
if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString();
else
sb.append((char)ch);
}
return null;
}
public void myClose() throws IOException{
r.close();
}

public static void main(String[] args)throws IOException{
FileReader fr = new FileReader("c:\\MyMenuDemo.java");
MyBufferedReader b =  new MyBufferedReader(fr);
String line = null;
while((line=b.myReadLine())!=null){
System.out.println(line);
}
b.myClose();
}
}

文件流
/**
* File常见方法：
* 1.创建
* boolean createNewFile():在制定位置创建文件，如果该文件已经存在，则不创建，返回false.
* 和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
* boolean mkdir():创建文件夹
* boolean mkdirs():创建多级文件夹
* 2.删除
* boolean delete():
* void deleteOnExit();在程序退出时删除制定文件
*
* 3.判断
* boolean exists():文件是否存在
* isFile():
* isDirectory();
* isHidden();
* isAbsolute();
* 4.获取信息
* @author xinglefly
* @version 1
*/

public class FileDemo {
public static void main(String[] args) throws IOException{
// consMethod();
// listDemo();
listRootsDemo();


File dir = new File("e:\\");
File[] arr = dir.listFiles(new FilenameFilter() {
public boolean accept(File dir, String name) {
/*sop("dir:"+dir+".....name::"+name);
if(name.endsWith(".java"))
return true;
else
return false;*/
return name.endsWith(".java");
}
});
sop("len:"+arr.length);
for(File f:arr){
sop(f);
}
}


//创建File对象
public static void consMethod() throws IOException{
File f1 = new File("c:\\a.txt");
File f2 = new File("c:\\abc","b.txt");

File d = new File("c:\\abc");
File f3 = new File(d,"c:\\c.txt");
sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);
File f4 = new File("c:\\"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
sop("f4:"+f4);

File f = new File("c:\\java\\day\\file2.txt");
// f.createNewFile();
// f.mkdir();

//记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。
//通过exists判断。
sop("dir:"+f.isDirectory());
sop("file:"+f.exists());
}
//获取文件列表
public static void listDemo(){
File f = new File("c:\\");
String [] names = f.list();//调用list方法的file对象必须是封装一个目录。该目录还必须存在。
for(String name:names){
sop(name);
}
}
public static void listRootsDemo(){
File[] files = File.listRoots();
for(File f:files){
sop(f);
}
}
public static void getEndsWith(){

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

}
import java.io.File;

/**
* 列出指定目录下文件或者文件夹，包含子目录中的内容。
* 也就是列出指定目录下所有内容。
*
* 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
* 在列出过程中出现的还是目录的话，还可以再次调用本功能。
* 也就是函数自身调用自身。
* 这种表现形式，或者编程手法，成为递归。
*
* 递归要注意：
* 1.限定条件。
* 2.要注意递归的次数。尽量避免内存溢出。
* @author xinglefly
* @version 1
*/
public class FileDemo3 {
public static void main(String[] args){
File dir = new File("C:\\tt");
showDir(dir,2);
// toBin(6);
// int n= getSum(10000);
// System.out.println("n="+n);
removeDir(dir);
}
public static int getSum(int n){
if(n==1)
return 1;
return n+getSum(n-1);
}
public static void toBin(int num){
if(num>0){
toBin(num/2);
sop(num%2);
}
}
public static String getLever(int level){
StringBuilder sb = new StringBuilder();
sb.append("|--");
for(int x=0;x<level;x++){
// sb.append("|--");
sb.insert(0, "|");
}
return sb.toString();
}
public static void showDir(File dir,int level){
System.out.println(dir);
level++;
File[] files = dir.listFiles();
for(int x=0;x<files.length;x++){
if(files[x].isDirectory())
showDir(files[x],level);
else
System.out.println(getLever(level)+files[x]);
}
}
//删除原理
//在window中，删除目录从里面往外删除的
//既然是从里往外删除。就需要用到递归。
public static void removeDir(File dir){
File[] files = dir.listFiles();
for(int x=0;x<files.length;x++){
if(files[x].isDirectory())
removeDir(files[x]);
else
System.out.println(files[x].toString());
}
System.out.println(dir+"::dir::"+dir.delete());
}
public static void sop(Object obj){
System.out.println(obj);
}

}

内存流
import java.io.*;

/**
* ByteArrayStream
* 用于操作字节数组的流对象。
* ByteArrayInputStream:在构造的时候，需要接收数据源， 而且数据源是一个字节数组。
* ByteArrayOutputStream:在构造的时候，不用定义数据目的，因为该对象中内部封装了可变长度的字节数组。
* 这就是数据目的地。
*
* 因为这两个流对象都操作的数组，并没有使用系统资源。
* 所以，不用进行close关闭。
*
* 在流操作规律讲解时：
* 源设备：
* 键盘 System.in，硬盘 FileStream，内存ArrayStream。
* 目的设备：
* 控制台 System.out, 硬盘 FileStream, 内存ArrayStream.
* @author xinglefly
* @version 1
*/
public class ByteArrayDemo {
public static void main(String[] args){
//数据源
ByteArrayInputStream bis = new ByteArrayInputStream("abcdefg".getBytes());
//数据目的
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int by = 0;
while((by=bis.read())!=-1){
bos.write(by);
}
System.out.println(bos.size());
System.out.println(bos.toString());
}
}


打印流
import java.io.*;

/**
* 打印流：
* 该流提供了打印方法，可以将各种数据类型的数据都原样打印。
*
* 字节打印流：
* PrintStream
* 构造函数可以接收的参数类型。
* 1.File对象
* 2.字符串路径。String
* 3.字节输出流.OutputSteam
*
* 字符打印流：
* PrintWriter
* 构造函数可以接收的参数类型：
* 1.File对象。
* 2.字符串路径。String
* 3.字节输出流。OutputStream
* 4.字符输出流，Writer
* @author xinglefly
* @version 1
*/
public class PrintSteamDemo {
public static void main(String[] args) throws IOException{
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(new FileWriter("c:\\a.txt"),true);
String line = null;
while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
out.println(line.toUpperCase());
}
out.close();
bufr.close();

}
}

import java.io.*;
/**
* 通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。readline的方法
* 能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？
* readLine方法是字符流BufferedReader类中的方法
* 那么能不能将字节流转成字符流在使用字符流缓冲区得readLine方法呢？
* @author xinglefly
* @version 1
*/
public class TransStreamDemo {
public static void main(String[] args)throws IOException{
/*//获取键盘录入对象
InputStream in = System.in;
//将字节流对象转成字符流对象，使用转换流，InputStreamReader
InputStreamReader isr = new InputStreamReader(in);
//为了提高效率，将字符串进行缓冲区技术高效操作。BufferedReader
BufferedReader bufr = new BufferedReader(isr);*/

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
/*OutputStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out);
BufferedWriter bufw = new BufferedWriter(osw);
*/
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
String line = null;
while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
// System.out.println(line.toUpperCase());
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
}

}


合并
/**
*
* @author xinglefly
* @version 1
*/
public class SequenceDemo {
public static void main(String [] args) throws IOException{
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("c:\\1.txt"));
v.add(new FileInputStream("c:\\2.txt"));
v.add(new FileInputStream("c:\\3.txt"));

Enumeration<FileInputStream> en = v.elements();
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("c:\\4.txt");
byte[] buf = new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();

}
}
拆
import java.io.*;
import java.util.*;

public class SplitFile {
public static void main(String[] args) throws IOException{
// splitFile();
merge();
}
public static void merge() throws IOException{
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=1;x<=21279;x++){
al.add(new FileInputStream("c:\\splitfiles"+x+".part"));
}
final Iterator<FileInputStream> it = al.iterator();
Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){
public boolean hasMoreElements(){
return it.hasNext();
}
public FileInputStream nextElement(){
return it.next();
}
};
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("c:\\0.jpg");
byte [] buf = new byte[1024*1024];
int len=0;
while((len=sis.read())!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
public static void splitFile() throws IOException{
FileInputStream fis = new FileInputStream("c:\\001.jpg");
FileOutputStream fos = null;

byte[] buf = new byte[1024*1024];

int len=0;
int count=1;
while((len=fis.read())!=-1){
fos=new FileOutputStream("c:\\splitfiles"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();

}

}
/**
*
* @author xinglefly
* @version 1
*/
public class PropertiesDemo {
public static void main(String[] args) throws IOException{
// setAndGet();
// method_1();
loadDemo();
}

public static void loadDemo() throws IOException{
Properties p = new Properties();
FileInputStream fis = new FileInputStream("c:\\systinfo.txt");

//将流中的数据加载进集合。
p.load(fis);
p.setProperty("wangwu", "39");
FileOutputStream fos = new FileOutputStream("c:\\info.txt");
p.store(fos, "haha");
p.list(System.out);

fos.close();
fis.close();


}

//演示，如何将流中的数据存储到集合中。
//想要将info.txt中键值数据存到集合中进行操作。
/*
* 1.用一个流和info.txt文件关联
* 2.读取一行数据，将该行数据用"="进行切割
* 3.等号左边作为键，右边作为值。存入到properties集合中即可。
*/
public static void method_1()throws IOException{
BufferedReader bufr = new BufferedReader(new FileReader("c:\\sysinfo.txt"));
String line = null;
Properties pro = new Properties();
while((line=bufr.readLine())!=null){
String [] arr = line.split("=");
System.out.println(arr[0]+"..."+arr[1]);
pro.setProperty(arr[0], arr[1]);
}
bufr.close();
System.out.println(pro);
}


public static void setAndGet(){
Properties p = new Properties();
p.setProperty("zhangsan", "30");
p.setProperty("lisi", "39");

System.out.println(p);
String value = p.getProperty("lisi");
System.out.println(value);
Set<String> names = p.stringPropertyNames();
for(String s:names){
System.out.println(s+"::"+p.getProperty(s));
}
}
}

/**
*
* @author xinglefly
* @version 1
*/

public class RunCount {
public static void main(String[] args) throws IOException{
/*
* 程序即使结束，该计数器的值也存在。
* 下次程序启动在会先加载该计数器的值并加1后在重新存储起来。
* 所以要建立一个配置文件。用于记录该软件的使用次数。
* 该配置文件使用键值对的形式。
* 这样便于阅读数据，并操作数据。
*
* 键值对数据是map集合。
* 数据是以文件形式存储，使用io技术。
* 那么map+io---->properties
*
* 配置文件可以实现应用程序数据的共享。
*/
Properties p = new Properties();
File file = new File("c:\\count.ini");
if(!file.exists())
file.createNewFile();
FileInputStream fis = new FileInputStream(file);
p.load(fis);
int count=0;
String value = p.getProperty("time");
if(value!=null){
count=Integer.parseInt(value);
if(count>=5){
System.out.println("您好，使用次数已到，拿钱！");
return ;
}
count++;
}

p.setProperty("time", count+"");
FileOutputStream fos = new FileOutputStream(file);
p.store(fos, "");
fos.close();
fis.close();
}
}

对像流
import java.io.*;

/**
* serializable 长期存储
* 堆类中封装的一些数据
* @author xinglefly
* @version 1
*/
class Person implements Serializable{
public static final long seriaVersonUID = 44L;
private String name;
transient int age;//关键字在堆中存在，不在文本中显示
static String country="cn";//静态是不能序列化的
Person(String name,int age,String country){
this.name=name;
this.age=age;
this.country=country;
}
public String toString(){
return "name:"+name+":"+age+":"+country;
}

}
public class ObjectStreamDemo {
public static void main(String[] args)throws Exception{
// Person p = new Person("zhangsan",32);
// writeObj();
readObj();
}
public static void writeObj(){
ObjectOutputStream out = null;
try{
out = new ObjectOutputStream(new FileOutputStream("c:\\obj.txt"));
out.writeObject(new Person("zhangsan",22,"EN"));
}catch(IOException e){
throw new RuntimeException("写入数据失败");
}finally{
try{
if(out!=null)
out.close();
}catch(IOException e1){
e1.printStackTrace();
}
}
}
public static void readObj() throws Exception{
ObjectInputStream in = null;
try{
in = new ObjectInputStream(new FileInputStream("c:\\obj.txt"));
Person p = (Person)in.readObject();
System.out.println(p);
}catch(IOException e){
throw new RuntimeException("读取数据失败!");
}finally{
try{
if(in!=null)
in.close();
}catch(IOException e1){
e1.printStackTrace();
}
}
}
}

管道流
/**
* 管道流
*
* @author xinglefly
* @version 1
*/
class Read implements Runnable{
public PipedInputStream pi;
Read(PipedInputStream pi){
this.pi=pi;
}
public void run(){
try{
byte[] buf = new byte[1024];

System.out.println("读取前，没有数据阻塞");
int len = pi.read(buf);
System.out.println("读到数据，阻塞结束");
String s = new String(buf,0,len);
System.out.println(s);
pi.close();
}catch(IOException e){
throw new RuntimeException("管道读取流失败");
}
}
}
class Write implements Runnable{
private PipedOutputStream out;
Write(PipedOutputStream out){
this.out=out;
}
public void run(){
try{
System.out.println("开始写入数据，请等待6秒");
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
out.write("piped is ok".getBytes());
out.close();
}catch(IOException e){
throw new RuntimeException("写入失败");
}
}
}
public class PipedStreamDemo {
public static void main(String[] args) throws IOException{
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);
Write w = new Write(out);
Read r = new Read(in);
new Thread(r).start();
new Thread(w).start();
}
}

随机Random
import java.io.*;
/**
* RandomAccessFile
* 这类不算是IO体系中子类，而是继承自Object。
* 内部封装了一个数组，而且通过指针对数组的元素进行操作。
* 可以通过getFilePointer获取指针对数组的元素进行操作。
* 同事可以通过seek改变指针的位置。
*
* 其实完成读写的原理就是内部封装了字节输入流和输出流。
* 通过构造函数可以看出，该类只能操作文件
* 而且操作文件还有模式：只读 r ,读写 rw等
*
* 如果模式为只读 r,不会常见文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
* 如果模式rw，操作的文件不存在，会自动创建，如果存在不会覆盖。
* @author xinglefly
* @version 1
*/
public class RandomAceessFileDemo {
public static void main(String[] args) throws IOException{
// wirteFile();
readFile();
System.out.println(Integer.toBinaryString(258));

}
public static void readFile() throws IOException{
RandomAccessFile raf = new RandomAccessFile("c:\\ran.txt","r");
//调整对对象中指针
// raf.seek(8*0);
//跳过指定的字节数
raf.skipBytes(4);
byte[] by = new byte[1024];
raf.read();
String name=new String(by);
int age = raf.readInt();
System.out.println("name:"+name);
System.out.println("age:"+age);
raf.close();
}
public static void wirteFile() throws IOException{
RandomAccessFile raf = new RandomAccessFile("c:\\ran.txt","rw");
raf.write("李四".getBytes());
// raf.write(258);
raf.writeInt(258);
raf.write("zhangsan".getBytes());
raf.writeInt(22);
raf.close();
}
}

Runtime对象
/**
* Runtime对象
* 该类并没有提供构造函数。
* 说明不可以new对象。那么会直接想到该类中的方法都是静态的。
* 发现该类中还有非静态方法。
* 说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。
* 由这个特点可以看出该类使用了单列设计模式完成。
*
* 该方式是static Runtime getRuntime();
* @author xinglefly
* @version 1
*/
public class RuntimeDemo {
public static void main(String[] args)throws Exception{
Runtime r = Runtime.getRuntime();
Process p = r.exec("notepad.exe  SystemDemo.java");
Thread.sleep(4000);
p.destroy();
}
}


Exception
/**
* 错误日志的记录
* @author xinglefly
* @version 1
*/
public class ExceptionInfo {
public static void main(String[] args){
try{
int[] arr = new int[2];
System.out.println(arr[3]);
}catch(Exception e){
try{
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = sdf.format(d);
PrintStream ps = new PrintStream("c:\\excetpion.log");
ps.println(s);
System.setOut(ps);
}catch(IOException ex){
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
}

}
}


编码
/**
*
* @author xinglefly
* @version 1
*/
public class EncodeDemo {
public static void main(String [] args) throws Exception{
String s = "你好";
byte[] b = s.getBytes("GBK");
System.out.println(Arrays.toString(b));
String s1 = new String(b,"utf-8");
System.out.println("s1="+s1);

//对s1进行iso8859-1编码。
byte[] b2 = s1.getBytes("iso8859-1");
System.out.println(Arrays.toString(b2));
String s2 = new String(b,"GBK");
System.out.println("s2="+s2);

System.out.println("--------------------------");
String a = "联通";
byte[] by = a.getBytes("gbk");
for(byte bt:by){
System.out.println(Integer.toBinaryString(bt&255));
}
}
}

    

    来源: 互联网  发布时间: 2014-02-18

intptr_t 其实不是指针类型 (转载)
原文地址http://blog.163.com/james_huangjian/blog/static/178049345201261643452479/

eflag寄存器
http://www.cnblogs.com/shenlian/archive/2011/05/22/2053857.html

intptr_t 其实不是指针类型  

2012-07-16 16:34:52|  分类： C++ |字号 订阅
intptr_t 其实不是指针类型
分类： C语言 2012-04-23 17:26 336人阅读 评论(0) 收藏 举报
 最近在看nginx源码，看到有一个类型intptr_t，没有见过，google了一下，有人说是指针类型，但是看nginx源码中对该类型变量的使用，好像不是指针类型。

[cpp] view plaincopy
static ngx_int_t  
 667 ngx_get_options(int argc, char *const *argv)  
 668 {  
 669     u_char     *p;  
 670     ngx_int_t   i;  
 671   
 672     for (i = 1; i < argc; i++) {  
 673   
 674         p = (u_char *) argv[i];  
 675   
 676         if (*p++ != '-') {  
 677             ngx_log_stderr(0, "invalid option: \"%s\"", argv[i]);  
 678             return NGX_ERROR;  
 679         }  
 680   
 681         while (*p) {  
 682   
 683             switch (*p++) {  
 684   
 685             case '?':  
 686             case 'h':  
 687                 ngx_show_version = 1;  
 688                 ngx_show_help = 1;  
 689                 break;  
其中ngx_int_t的定义如下：
[cpp] view plaincopy
78 typedef intptr_t        ngx_int_t;  


于是在linux的头文件中查找这个类型的定义，在/usr/include/stdint.h这个头文件中找到了这个类型的定义（不知道怎么在这里插入图片，所以使用文字）：

                           

[cpp] view plaincopy
117 /* Types for `void *' pointers.  */  
118 #if __WORDSIZE == 64  
119 # ifndef __intptr_t_defined  
120 typedef long int        intptr_t;  
121 #  define __intptr_t_defined  
122 # endif  
123 typedef unsigned long int   uintptr_t;  
124 #else  
125 # ifndef __intptr_t_defined  
126 typedef int         intptr_t;  
127 #  define __intptr_t_defined  
128 # endif  
129 typedef unsigned int        uintptr_t;  
130 #endif  

很明显intptr_t不是指针类型，但是上边的一句注释（/* Types for `void *' pointers. */）让人很疑惑。既然不是指针类型，但是为什么说类型是为了“void *”指针？
又查了一下在《深入分析Linux内核源码》中找到了答案，原文描述如下：

尽管在混合不同数据类型时你必须小心, 有时有很好的理由这样做. 一种情况是因为内存存取, 与内核相关时是特殊的. 概念上, 尽管地址是指针, 内存管理常常使用一个无符号的整数类型更好地完成; 内核对待物理内存如同一个大数组, 并且内存地址只是一个数组索引. 进一步地, 一个指针容易解引用; 当直接处理内存存取时, 你几乎从不想以这种方式解引用