新浦京81707con > 首页 > 使用Intent传递对象

原标题:使用Intent传递对象

浏览次数:145 时间:2019-05-07

        摘要:学习c#现已有壹段历程了,回想在此之前所打过的代码以及笔记,做些常用的下结论,希望现在专门的学问中假诺应用,方便搜索。当然,个人重大目标是如此,加深圳电影业公司像的同时,能够演习一下打字速度。希望也 坚定不移。当然,假若对其余人能带来一丢丢帮扶的话,那更加好啊。

第一组:刘聪 Request.Form、Request. QueryString、Request、Request.Params的区别

  1. Request.Form:获取以POST格局提交的多寡(接收Form提交来的多寡);
  2. Request. QueryString:获取地址栏参数(以GET情势提交的数码)
  3. Request:包涵以上三种办法(优先获得GET格局提交的数据),它会在QueryString、Form、ServerVariable中都按先后顺序搜寻二回。
  4. Request.Params是兼具post和get传过来的值的成团,request.params其实是多个会集,它每一个蕴涵request.QueryString、request.Form、request.cookies和request.ServerVariable。

再正是有时也会收获区别的结果。要是你1味是亟需Form中的多个数目,不过你采纳了Request而不是Request.Form,那么程序将要QueryString、ServerVariable中也招来三回。纵然恰巧你的QueryString大概ServerVariable里面也有同名的项,你猎取的就不是您原来想要的值了。


 

      

第一组:冯佳丽 使用Intent传递对象

——转载

我们能够在Intent中加多一些叠加数据,已达到规定的标准传值的功效,比如在First Activity中增加以下代码:

Intent intent = new Intent();
intent.putExtra("string_data","hello");
intent.putExtra("int_data",100);
startActivity(intent);

从此现在就能够在SecondActivity中取得这么些值了,代码如下:

getIntent().getStringExtra("string_data");getIntent().getIntExtra("int_data",0);

不过putExtra()方法所支撑的数据类型是零星的,即便常用的片段门类是有限的,可是当你想传递一些自定义的靶龙时,就能够意识不能动手

为此大家就该学习一下使用Intent来传递对象的技能

1.     File类

正文涉及内容:

         一、常用对字符串操作         二、集结           叁、文件操作

 

1、常用对字符串操作:

a、字符串截取(Substring):

string str = "我爱中华人民共和国";
str = str.Substring(2, 4);          //参数1:开始截取的索引(从0开始)  参数2:截取的长度  

b、字符串以怎么着伊始,以如何最终:

 str.StartsWith("我");           str.EndsWith("国");          //返回true 或者false

c、字符串分割:比较常用,对字符串实行分割,常用于操作把多个字符串分成3个字符串数组,依照字符串的特征,采取要求的局地。

   string serverData = "ok:操作成功";
   string[] data = serverData.Split(':');    
//  string[] data = serverData.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);           //这种方式可以在char数组中多添加需要截取掉的字符串
    for (int i = 0; i < data.Length; i  )
    {  Console.WriteLine(data[i]);  }         //结果为: ok   和  操作成功

d、比较多个字符串是不是1致并忽略大小写(Equals:参数二能够接纳两种相比艺术,常用:相比八个object

string str1=abc;   string str2 = abC;
bool b = str1.Equals(str2, StringComparison.OrdinalIgnoreCase);   //结果为:true

e、字符串数组插入操作:Join

 string[] str = { "张三", "李四", "王五"};
 string str2 = string.Join("|", str);             //输出结果为:张三|李四|王五  插入到每个数组元素的中间

总计:字符串还有众多操作,使用功能相比高的就地点这么些,当然,c#有个别用方都能够点出来然后看文字表达去行使

 

1.使用Serializable

Serializable是连串化的意味,表示将多少个对象转化成可累积也许可传输的图景,只须要让贰个类去完毕Serializable那么些接口就能够了,代码如下:

package com.example.lab.android.nuc.uibestpractice;import java.io.Serializable;public class Person implements Serializable {
    private String name;    private int 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;    }
}

接下去在FirstActivity中的代码也万分轻松:

Person person = new Person();person.setName("wanghao");person.setAge(18);Intent intent = new Intent(MainActivity.this,SecondActivity.class);intent.putExtra("person_data",person);startActivity(intent);

接下去在SecondActivity中拿走这几个目的也很简短:

Person person = (Person) getIntent().getSerializableExtra("person_data");

1.1. File类说明

积累在变量,数组和对象中的数据是临时的,当程序终止时他俩就可以丢失.为了能够永

久的保存程序中创建的数额,供给将她们存款和储蓄到硬盘或光盘的文本中.那么些文件能够运动,传送,亦能够被其它程序使用.由于数量存款和储蓄在文件中,所以大家需求上学3个和文书有密切关系的类,叫做File类,将在通晓获取文件的品质以及去除和重命名文件.最后怎样向文件中写入数据和从文件中读取数据.

这正是说File类关怀的是在磁盘上文件的存款和储蓄.

File类描述的是1个文件或文件夹。(文件夹也得以称呼目录)

此类的产出是对文件系统的中的文件以及文件夹举行对象的卷入。能够由此对象的挂念来操作文件以及文件夹。

    能够用面向对象的拍卖难题,通过该对象的办法,能够得到文件或文件夹的音信便民了对文件与公事夹的质量音信进行操作。

    文件包蕴众多的新闻:如文件名、成立修改时间、大小、可读可写属性等。

2:集合

会面是三个很常用的东西 。常用的会集有:键值对聚焦,泛型集结

ArrayList(集结):可添增加少

Hashtable(键值对聚焦):键值可感觉其他方式的数据类型

Dictionary键值对集中(常用):

Dictionary<int, string> dic = new Dictionary<int, string>();    //涉及到键必须为int类型,值必须为string类型
dic.Add(1, "张三");    //添加数据
dic.Remove(1);   //传进来的是键标
dic.Clear();    //清空集合

List泛型集结(常用):

List <int> list= new List<int>();    //声明
list.Add(1); //添加数据
list.AddRange(new int[] { 3,4,5,6,7,8,9});  //添加集合
list.RemoveAt(2);   //索引下标从0开始
list.RemoveRange(2, 4);    //从索引2开始,移除4个元素
list.Clear();//清空集合

聚拢相比常用,用法也相对相比轻便。常用的有众多,比方:Contains(是或不是含有) FirstOrDefault:第三个因素,.ToArray :转变为数组 等  能够list然后点出来,再依附表达

 

2.使用Parcelable

除去Serializable之外,使用Parcelable能够完毕平等的效能,但是不一样于将目标类别化,Parcelable格局的法则是讲贰个完好无损的靶子进行表达,而分解后的每1有的都以Intent所支撑的品种,代码如下:

package com.example.lab.android.nuc.uibestpractice;import android.os.Parcel;import android.os.Parcelable;public class People implements Parcelable {

    private String name;    private int age;    @Override    public int describeContents() {
        return 0;    }

    @Override    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);//写出name        dest.writeInt(age);//写出age    }

    public static final Parcelable.Creator<People> CREATOR = new Parcelable.Creator<People>(){

        @Override        public People createFromParcel(Parcel source) {
            People people = new People();//            读取的顺序一定要和上面的一样            people.name = source.readString();//读取姓名            people.age = source.readInt();//读取年龄            return people;        }

        @Override        public People[] newArray(int size) {
            return new People[size];        }
    };}

首先大家让People类去达成了Parcelable接口,这样就不能不重写describeContents()和writeToParcel()那五个主意,其中describeContents()方法间接再次来到0就足以了,而writeToParcel()大家供给调用Parcel的writeXxx()方法,将People类的字段11写出。

除了那个之外,大家还必须在People类中提供一个名叫CREATO凯雷德的常量,这里创办了三个Parcelable.Creator接口的三个实现,并将泛型钦点为People,接着要重写createFromParcel()和呢笔者Array()这三个艺术,在createFromParcel()方法里面大家要读取刚才的字段,并创建2个指标开始展览重返。

在FirstActivity中大家照例能够运用同样的代码来传递People对象,只可是在SecondACtivity中赢得对象的时候稍作修改:

Person person = (Person) getIntent().getParcelableExtra("person_data");

1.2. 体验File类

查验钦定路径下是或不是留存钦定的目录可能文件.

// 检验指定路径下是否存在指定的目录或者文件.

       File file = new File("c:\a.txt");

       System.out.println(file.exists());

// File对象是否是目录

       System.out.println(file.isDirectory());

// 对象是否是文件

        System.out.println(file.isFile());

 

 

敲定:File对象也能够表示不存在的文件。其实代表了2个虚幻路线

构建二个File类的实例并不会在机械上创造二个文件.不管文件是不是存在都可以创造任意文件名的File实例,能够调用File实例的exists方法判定文件或目录是不是存在

三、文件操作

摘要:文件操作是有些种类中不可或缺的,对一些上传图片的门径操作,对写入的局地文书档案,日志文件进行保存之类

a:专门操作路线的path类 :(静态类)

using System.IO;
string str = @"C:Program Files (x86)IISMicrosoft Web Deploy V3esC#.txt";
Path.GetFileName(str);  //获取文件名
Path.GetFileNameWithoutExtension(str);    //没有扩展名的文件名
Path.GetExtension(str);   //获取文件扩展名
Path.GetFullPath(str);  //获取文件绝对路径
Path.Combine(@"c:abc", @"f.avi");  //把两个路径融合
Path.GetDirectoryName(str);    //获取路径名,没有文件名

关联到路线就选用Path,有时候常常和File混合,恐怕是个人原因

 

b:File读写多少

  (1):以字节格局读取:

byte[] bte = File.ReadAllBytes(@"C:Usersxsh.csDesktopnew.txt");
string str = Encoding.Default.GetString(bte);   //转换为字符串(最适用)   还有:UTF8Encoding.Default.GetString(bte)、Encoding.GetEncoding("GB2312").GetString(bte)
                                                                           、ASCIIEncoding.Default.GetString(bte)  等多种编码格式

 (二):逐行读取

string[] st = File.ReadAllLines(@"C:UsersAdministratorDesktopnew.txt", Encoding.Default);   //逐行读取内容  遍历数组 可对每一行进行操作

(三):以文本 情势读取

string str = File.ReadAllText(@"C:UsersAdministratorDesktopnew.txt", Encoding.Default);   //以文本形式读取  对于图片类,视频文件类 等其他类 不适用

(a):以字节情势写多少

byte[] by = Encoding.Default.GetBytes(str);
File.WriteAllBytes(@"C:UsersPathnew.txt",by);      

(b):以数组的样式逐行写数据 

File.WriteAllLines("new.txt",strArray);   //strArray为定义的数组

(c):全部写入

File.WriteAllText("new.txt",str);  //整体写入,最常用的方式 str为字符串

(d):追加

File.AppendAllText("new.txt",str);
File.AppendAllLines("new.txt",str);  //逐行追加

 

c:FileStream文件流

   (一):读取文件:

using (FileStream fread= new FileStream(@"C:Userspath.txt", FileMode.OpenOrCreate, FileAccess.Read))
{
    byte[] buffer = new byte[1024 * 1024 * 2];
    int r = fread.Read(buffer, 0, buffer.Length);   //返回当前读取的有效字节数
    string str = Encoding.Default.GetString(buffer, 0, r);   //解码
}
 //参数①: 针对哪一个文件  写文件路径  
 //参数②: 要对此文件进行怎样的操作  
//参数③: 要对此文件的数据进行怎样的操作 

(2):写文件:

 using (FileStream fwrite = new FileStream(@"C:Users文件流.txt",FileMode.OpenOrCreate, FileAccess.Write))
 {
    byte[] buffer = Encoding.Default.GetBytes(str);   //str为字符串
    fwrite.Write(buffer, 0, buffer.Length);
 }

(三):复制文件:

 string path = @"C:Usersvideo.avi";
 string newpath = @"C:UsersvideoNew.avi";
  //创建一个负责读取的文件流  
 using (FileStream fread = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Read))
 {
   //创建一个写入文件的文件流
     using (FileStream fwrite = new FileStream(newpath, FileMode.OpenOrCreate, FileAccess.Write))
     {
        byte[] buffer = new byte[1024 * 1024 * 5];
        while (true)   //文件过大,可能一次读写不完,需要循环
        {
          int r = fread.Read(buffer, 0, buffer.Length);
           if (r == 0)                //当读取不到字节时,说明已经完毕,则跳出循环
            {
               break;
            }
              else
             fwrite.Write(buffer, 0, r);
        }
     }
       Console.WriteLine("复制成功!");
   }

干什么采纳using?  当1个类最后承继IDisposable 这么些接口,就须要到自由财富空间,用using就足以自动释放能源空间,进步效用,减弱代码量

 

d:StreamReader和StreamWriter

//读取
using (StreamReader sRead = new StreamReader(@"C:UsersPath.txt", Encoding.Default))
 {
    while (!sRead.EndOfStream)   //指示当前流的位置是否为结尾
     {
         Console.WriteLine(sRead.ReadLine());
     }
 }

//写入
 using (StreamWriter stwr =new StreamWriter(@"C:UsersPath.txt",true,Encoding.Default))
{
     stwr.Write(str);
}

 

小结:两种艺术都足以对文件举办读写操作,相对Stream用的可比多一些,用法很简短,根据write 恐怕read的方法,传入相应的参数就可以。

 

总结:c#有不小学一年级部分基础语法,最关键的会动用微软卷入的一些类,一些情势。看那个类的艺术的重载。要是有vs的那些语言包,都得以看每一个办法重载是做哪些的,然后相应的利用。传入相应要求的参数,看再次回到值。

 

第三组:胡耀淦 C# 文件操作

一、专门操作路线的path类 (静态类)

using System.IO;
string str = @"C:Program Files (x86)IISMicrosoft Web Deploy V3esC#.txt";
Path.GetFileName(str);  //获取文件名
Path.GetFileNameWithoutExtension(str);    //没有扩展名的文件名
Path.GetExtension(str);   //获取文件扩展名
Path.GetFullPath(str);  //获取文件绝对路径
Path.Combine(@"c:abc", @"f.avi");  //把两个路径融合
Path.GetDirectoryName(str);    //获取路径名,没有文件名

关联到路线就动用Path,有时候平时和File混合

二、File读写多少

(一):以字节格局读取:

byte[] bte = File.ReadAllBytes(@"C:Usersxsh.csDesktopnew.txt");
string str = Encoding.Default.GetString(bte);   //转换为字符串(最适用)   还有:UTF8Encoding.Default.GetString(bte)、Encoding.GetEncoding("GB2312").GetString(bte)、ASCIIEncoding.Default.GetString(bte)  等多种编码格式

(贰):逐行读取

string[] st = File.ReadAllLines(@"C:UsersAdministratorDesktopnew.txt", Encoding.Default);   
//逐行读取内容  遍历数组 可对每一行进行操作

(三):以文本 形式读取

string str = File.ReadAllText(@"C:UsersAdministratorDesktopnew.txt", Encoding.Default);  
 //以文本形式读取  对于图片类,视频文件类 等其他类 不适用

(a):以字节方式写多少

byte[] by = Encoding.Default.GetBytes(str);
File.WriteAllBytes(@"C:UsersPathnew.txt",by);     

(b):以数组的花样逐行写多少

File.WriteAllLines("new.txt",strArray);   //strArray为定义的数组

(c):全部写入

File.WriteAllText("new.txt",str);  //整体写入,最常用的方式 str为字符串
(d):追加
File.AppendAllText("new.txt",str);
File.AppendAllLines("new.txt",str);  //逐行追加

3、FileStream文件流

(壹):读取文件:

using (FileStream fread= new FileStream(@"C:Userspath.txt", FileMode.OpenOrCreate, FileAccess.Read))
{
    byte[] buffer = new byte[1024 * 1024 * 2];
    int r = fread.Read(buffer, 0, buffer.Length);   //返回当前读取的有效字节数
    string str = Encoding.Default.GetString(buffer, 0, r);   //解码
}
 //参数①: 针对哪一个文件  写文件路径  
 //参数②: 要对此文件进行怎样的操作  
//参数③: 要对此文件的数据进行怎样的操作 

(2):写文件:

 using (FileStream fwrite = new FileStream(@"C:Users文件流.txt",FileMode.OpenOrCreate, FileAccess.Write))
 {
    byte[] buffer = Encoding.Default.GetBytes(str);   //str为字符串
    fwrite.Write(buffer, 0, buffer.Length);
 }

(三):复制文件:

string path = @"C:Usersvideo.avi";
 string newpath = @"C:UsersvideoNew.avi";
  //创建一个负责读取的文件流  
 using (FileStream fread = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Read))
 {
   //创建一个写入文件的文件流
     using (FileStream fwrite = new FileStream(newpath, FileMode.OpenOrCreate, FileAccess.Write))
     {
        byte[] buffer = new byte[1024 * 1024 * 5];
        while (true)   //文件过大,可能一次读写不完,需要循环
        {
          int r = fread.Read(buffer, 0, buffer.Length);
           if (r == 0)                //当读取不到字节时,说明已经完毕,则跳出循环
            {
               break;
            }
              else
             fwrite.Write(buffer, 0, r);
        }
     }
       Console.WriteLine("复制成功!");
   }

4、StreamReader和StreamWriter

//读取
using (StreamReader sRead = new StreamReader(@"C:UsersPath.txt", Encoding.Default))
 {
    while (!sRead.EndOfStream)   //指示当前流的位置是否为结尾
     {
         Console.WriteLine(sRead.ReadLine());
     }
 }

//写入
 using (StreamWriter stwr =new StreamWriter(@"C:UsersPath.txt",true,Encoding.Default))
{
     stwr.Write(str);
}

小结:三种方法都足以对文件实行读写操作,相对Stream用的可比多一些,用法很轻松,依照write 或然read的不二诀要,传入相应的参数就可以。


一.三. 构造二个File类实例:

new File(String pathname);

        通过将给定路径来创建一个新File实例。

new File(String parent, String child);

        根据parent路径名字符串和child路径名创建一个新File实例。

         parent是指上级目录的路径,完整的路径为parent child.

new File(File parent, String child);

        根据parent抽象路径名和child路径名创建一个新File实例。

        parent是指上级目录的路径,完整的路径为parent.getPath() child.

说明:

       如果指定的路径不存在(没有这个文件或是文件夹),不会抛异常,这时file.exists()返回false。

 

    新建File对象File file=new File();

public static void main(String[] args) {

       File file = new File();

    }

 

一:创造File对象急需导包,   import java.io.File

二:File对象未有无参数构造.创设对象须求传参.

    依据API文书档案提示,传入2个文件的字符串路径. String path="c:/a.txt";

(a.txt 文件在c盘下已经存在)

 

//file 是一个文件对象

       String path = "c:/a.txt";

       File file = new File(path);

 

File类的靶子,既能够表示文件也能够表示文件夹。

 

public static void main(String[] args) {

       //file 是一个文件夹

       String path = "c:/test";

       File file = new File(path);

    }

 

第四组:李俊 Dev gridcontrol获取选定行,钦点列单元格的内容

[csharp] 
1.  //mOIDFiledName为要获取列的列名  
2.  private string GetSelectOID(string mOIDFiledName)  
3.  {  
4.      int[] pRows = this.gridView1.GetSelectedRows();//传递实体类过去 获取选中的行  
5.      if (pRows.GetLength(0) > 0)  
6.          return gridView1.GetRowCellValue(pRows[0], mOIDFiledName).ToString ();  
7.      else  
8.          return null;  
9.  }  

小注:
得到GridView中具有的当选的行号

int[] iRowId = this.gridData.gridView1.GetSelectedRows();

1.4. 路径:

    路线正是文本或文件夹所在的职位。

 

第伍组:周倩宇 jQuery Password Validation(密码验证)

来源:https://www.w3cschool.cn/jquery/jquery-plugin-password-validation.html

jQuery Password Validation(密码验证)插件扩展了 jQuery Validate 插件,

提供了两种组件:
一种评价密码的相关因素的作用:举个例子大小写字母的混合境况、字符(数字、特殊字符)的和弄情形、长度、与用户名的相似度(可选的)。

1种接纳评价功效展现密码强度的表明插件自定义方法。显示的文书能够被当地化。
可以简单地自定义强度彰显的外观、本地化新闻显示,并集成到已某个表单中。

运用方法:

如需使用 Password Validation(密码验证)插件,
请增加3个 class "password" 到 input,同时丰裕显示强度的中央标识在表单的需求出示的地方:

<form id="register">
    <label for="password">Password:</label>
 <input class="password" name="password" id="password" />
  <div class="password-meter">
      <div class="password-meter-message"> </div>
     <div class="password-meter-bg">
           <div class="password-meter-bar"></div>
      </div>
  </div>
</form>
对表单应用 Validate 插件:
$(document).ready(function() {
  $("#register").validate();
});

能够重载 $.validator.passwordRating 落成不一致的评头品足办法。
或然重载 $.validator.passwordRating.messages 来提供任何音信,举例当地化。

一.四.壹.    路线分割符:

    上下级文件夹之间接选举用分隔符分开:

    在Windows中分隔符为'',在Unix/Linux中分隔符为'/'。

跨平台的目录分隔符

    更专门的学业的做法是行使File.separatorChar,那几个值就能依据系统得到的对应的分割符。

例:new File("c:" File.separatorChar "a.txt");

在意,就算是利用"",则必要展开转义,写为"\"才足以,假设是五个"",则写为"\\"。

 

实验:

在以下代码的path处写不同的路径试一下,并观察输出结果。

           File file = new File(path);

           System.out.println(file.getAbsolutePath());

 

壹.四.二.    相对路线与相对路线:

对此UNIX平台,相对路线名的前缀是"/"。相对路线名未有前缀。

对于Windows平台,相对路线名的前缀由驱动器号和3个":"组成,例"c:\..."。相对路线未有盘符前缀。

相对路线:

    相对路线是指相对于某地方的渠道,是指相对于当前目录。

    在施行Java程序时,相对路线为实践java命令时当前所在的目录。

实验:

在不同的路径下执行java命令运行以下程序,并观察输出结果。

       File file = new File("a.txt");

       System.out.println(file.getAbsolutePath());

一般在使用时,建议用绝对路径,因为相对路径容易出问题,不好确定到底在什么地方。

//相对路径

//File file = new File("src/a.txt");

 

 

             

 

 

壹.5. File类中常用的章程:

    创建:

    createNewFile()   在指定位置创建一个空文件,成功就返回true,如果已存在就不创建然后返回false

       mkdir()           在指定位置创建目录,这只会创建最后一级目录,如果上级目录不存在就抛异常。

       mkdirs()      在指定位置创建目录,这会创建路径中所有不存在的目录。

       renameTo(File dest)  重命名文件或文件夹,也可以操作非空的文件夹,文件不同时相当于文件的剪切,剪切时候不能操作非空的文件夹。移动/重命名成功则返回true,失败则返回false。

 

   

    删除:

delete()      删除文件或一个空文件夹,如果是文件夹且不为空,则不能删除,成功返回true,失败返回false。

       deleteOnExit()    在虚拟机终止时,请求删除此抽象路径名表示的文件或目录,保证程序异常时创建的临时文件也可以被删除

 

      

    判断:

exists()      文件或文件夹是否存在。

       isFile()      是否是一个文件,如果不存在,则始终为false。

       isDirectory() 是否是一个目录,如果不存在,则始终为false。

       isHidden()    是否是一个隐藏的文件或是否是隐藏的目录。

       isAbsolute()  测试此抽象路径名是否为绝对路径名。

 

      

    获取:

getName()     获取文件或文件夹的名称,不包含上级路径。

getPath()       返回绝对路径,可以是相对路径,但是目录要指定

getAbsolutePath() 获取文件的绝对路径,与文件是否存在没关系

length()      获取文件的大小(字节数),如果文件不存在则返回0L,如果是文件夹也返回0L。

getParent()       返回此抽象路径名父目录的路径名字符串;如果此路径名没有指定父目录,则返回null。

lastModified()    获取最后一次被修改的时间。

    文件夹相关:

staic File[] listRoots() 列出所有的根目录(Window中就是所有系统的盘符)

list()                   返回目录下的文件或者目录名,包含隐藏文件。对于文件这样操作会返回null。

list(FilenameFilter filter) 返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。

listFiles()                 返回目录下的文件或者目录对象(File类实例),包含隐藏文件。对于文件这样操作会返回null。

listFiles(FilenameFilter filter)   返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。

 

      

 

 

 

1.6. 案例:

    1,列出钦点目录中具备的子文件名与具备的子目录名。

    二,列出钦命目录中持有的子文件名与持有的子目录名,需要目录名与公事名分开列出,格式如下:

       子目录:

           ...

           ...

       子文件:

           ...

           ...

    三,列出钦点目录中存有扩充名称为.java的文书。

    四,列出内定目录中保有扩张名称叫.class的文件。

    伍,思索第一与第5题,代码是或不是双重呢,假设想要列出当中的全体.txt文件,是或不是要再写三个类呢?

       a, 请自行设计一个工具方法,能够传递钦点的恢弘名,工具方法会过列出钦赐目录中钦点扩大名的全部子文件与子文件夹。

       b, 请利用FilenameFilter接口写二个工具类,能够传递钦定的过滤规则。

    陆,列出钦赐目录中具有的子孙中山件与儿孙目录名,只必要列有名称就可以。

 

解题: 列出钦赐目录中装有的子文件名与有着的子目录名。

需求1:获取所有的c:/test 即test目录下的所有文件和文件夹

解题思路:  

   代码需要封装,就需要创建方法,并在main方法中调用和测试. 方法名要有意义: listAllFilesAndDirs

第一步:创建File对象

    第二步:查找File类中可用的方法,想要获取该目录下的所有子文件和子目录

    第三步:显示这些文件和文件夹的名称

实现:

/**

     * 列出指定目录中所有包含的子文件与子目录

     */

    public static void listAllFilesAndDirs(String path) {

       // 1.创建File对象,表示这个目录

       File dir = new File(path);

       // 2.通过list方法得到所包含的所有子目录与子文件名称

       String[] names = dir.list();

       // 3显示这些名称

       for (int i = 0; i < names.length; i ) {

           System.out.println(names[i]);

       }

    }

 

解题: 列出钦赐目录中具备的子文件名与具备的子目录名,供给目录名与公事名分开列出

案例1把文件和文件夹都列了出来,可是力不从心区分文件和文书夹.File类有咬定文件和文件夹的方法,可是list方法重返的是String数组,那些list() 方法不能满足大家的要求.继续搜索File的方法.查看api找到 File[] listFiles()  开采该方法再次来到的是一个File数组。

思路:

第一步:创建listAllFilesAndDirs(String path)方法,接受路径

第二步: 创建File对象表示这个目录

第三步: 通过listFiles方法得到所包含的所有子目录与子文件名称

第四步: 得到所有的文件名集合,与所有的文件夹名集合

第五步: 分别显示文件名与文件夹名

实现

public static void listAllFilesAndDirs2(String path) {

       // 1.创建File对象,表示这个目录

       File dir = new File(path);

       // 2通过listFiles方法得到所包含的所有子目录与子文件名称

       File[] names = dir.listFiles();

       // 3,分别显示文件名与文件夹名

       for (int i = 0; i < names.length; i ) {

           File file = names[i];

           if (file.isFile()) {

              System.out.println(("子文件:"));

              System.out.println("t" file.getName());

           } else if (file.isDirectory()) {

              System.out.println(("子目录:"));

              System.out.println("t" file.getName());

           }

       }

    }

实现二:

public static void listAllFilesAndDirs(String path) {

       //1创建File对象表示这个目录

       File dir = new File(path);

      

       //2通过listFiles方法得到所包含的所有子目录与子文件名称

       File[] names = dir.listFiles();

       

       //3,得到所有的文件名集合,与所有的文件夹名集合

       List<File> filesList = new ArrayList<File>();

       List<File> dirsList = new ArrayList<File>();

       for (int i = 0; i < names.length; i ) {

           File file = names[i];

           if (file.isFile()) {

              filesList.add(file);

           } else if (file.isDirectory()) {

              dirsList.add(file);

           }

       }

      

       //4,分别显示文件名与文件夹名

       System.out.println("子文件:");

       for (int i = 0; i < filesList.size(); i ) {

           System.out.println("t" filesList.get(i).getName());

       }

       System.out.println("子目录:");

       for (int i = 0; i < dirsList.size(); i ) {

           System.out.println("t" dirsList.get(i).getName());

       }

    }

 

演练三,列出钦命目录中具备扩大名叫.java的公文。

需求: 从指定目录中找到指定扩展名的文件,并列出来

思路

第一步: 创建lsitAllFiles方法,接受路径和文件后缀名

第二步: 获取所有的子文件和子文件夹

第三步: 从中找出符合条件的文件并显示出来

 

在意:不相同系统对于路径的 windows系统使用斜线作为路线分隔符 "" linux 系统利用反斜线作为路线分隔符"/"java是跨平台的言语,java程序1旦安顿到linux系统上,若是程序中有File对象, 能够应用File类separatorChar (字段)

 

public class FileTest2 {

    public static void main(String[] args) {

       String path = "c:" File.separatorChar "test";

       File file = new File(path);

       listtAllFiles(file, "java");

    }

 

    /**

     * 从指定目录中找到指定扩展名的文件,并列出来

     *

     */

    public static void listtAllFiles(File dir, String extension) {

       // 1.获取所有的子文件和子文件夹

       File[] files = dir.listFiles();

 

       // 2.从中找出符合条件的文件并显示出来

       for (int i = 0; i < files.length; i ) {

           File file = files[i];

           // 3.需要以指定文件后缀结尾才算符合条件

           if (file.getName().endsWith(extension)) {

              System.out.println(file.getName());

           }

       }

    }

}

 

练习4:

public class FileTest2 {

    public static void main(String[] args) {

       String path = "c:" File.separatorChar "test";

       File file = new File(path);

       listtAllFiles2(file, "txt");

    }

 

 

    /**

     * FilenameFilter接口写一个工具类,可以传递指定的过滤规则。

     *  从指定目录中找到指定扩展名的文件,并列出来

     *

     * */

    public static void listtAllFiles2(File dir, String name) {

       // 1.获取所有的子文件和子文件夹

       String[] files = dir.list(new DirFilter("txt"));

 

       // 2显示名称

       for (int i = 0; i < files.length; i ) {

           System.out.println(files[i]);

       }

    }

}

 

class DirFilter implements FilenameFilter {

    private String extension;

 

    public DirFilter() {

 

    }

 

    public DirFilter(String extension) {

       this.extension = extension;

    }

 

    @Override

    public boolean accept(File dir, String name) {

       return name.endsWith(extension);

    }

}

留神: DirFilter 正是贯彻了accept 方法.提须求File类的list方法使用.

 

二.     IO流体验与简要介绍

 

File对象足以象征存在的文本或文件夹,也足以代表不存在的。

大家想要获得文件的内容咋办,File只是操作文件,文件的剧情如何管理就须求利用io流工夫了。

譬如说在C盘下有三个称号为a.txt的文件文件.想要通过Java程序读出来文件中的内容,供给利用IO流本领.一样想要将顺序中的数据,保存到硬盘的文本中,也急需IO流能力.

读和写文件文件示例:

public class IoTest {

    public static void main(String[] args) throws FileNotFoundException,

           IOException {

       writFileTest();

 

       readFileTest();

    }

 

    private static void writFileTest() throws FileNotFoundException,

           IOException {

       // 创建文件对象

       File file = new File("c:\a.txt");

       // 创建文件输出流

       FileOutputStream fos = new FileOutputStream(file);

       fos.write('g');

       fos.write('z');

       fos.write('i');

       fos.write('t');

       fos.write('c');

       fos.write('a');

       fos.write('s');

       fos.write('t');

       fos.close();

    }

 

    private static void readFileTest() throws FileNotFoundException,

           IOException {

       // 创建文件对象

       File file = new File("c:\a.txt");

       // 创建文件输入流

       FileInputStream fis = new FileInputStream(file);

       // 有对多长,就读多少字节。

       for (int i = 0; i < file.length(); i ) {

           System.out.print((char) fis.read());

       }

       fis.close();

    }

}

 

 

当成功流的读写时,应该经过调用close方法来关闭它,那些艺术会自由掉这么些个别的操作系统能源.假设三个应用程序张开了过多的流而并未有安息它们,那么系统能源将被耗尽.

IO流简介:(Input/Output)

    I/O类库中采用“流”这么些抽象概念。Java对设备中多少的操作是通过流的方法。

    表示别的有力量出现数据的数据源对象,或许是有技艺接受多少的接收端对象。“流”屏蔽了事实上的I/O设备中管理数量的细节。IO流用来拍卖设备之间的数目传输。设备是指硬盘、内部存款和储蓄器、键盘录入、网络等。

    Java用于操作流的靶子都在IO包中。IO流本领首要用于处理设备之间的数量传输。

    由于Java用于操作流的目的都在IO包中。所以采纳IO流须求导包如:import java.io.*;

IO流的分类

    流按操作数据类型的不如分为二种:字节流与字符流。

    流按流向分为:输入流,输出流(以程序为参照物,输入到程序,或是从程序输出)

3.     字节流

怎么是字节流

    Computer中都以二进制数据,一个字节是8个2进制位.字节能够象征拥有的多寡,比方文本,音频,录像.图片,都以当做字节存在的.也正是说字节流处理的数量卓殊多。

在文书文件中蕴藏的数量是以大家能读懂的情势表示的。而在二进制文件中贮存的数码是用2进制形式表示的。我们是读不懂2进制文件的,因为2进制文件是为了让程序来读取而安插的。举例,Java的源程序(.java源文件)存款和储蓄在文件文件中,能够行使文本编辑器阅读,不过Java的类(字节码文件)存款和储蓄在贰进制文件中,能够被Java虚拟机阅读。贰进制文件的优势在于它的管理成效比文本文件高。

    我们曾经知道File对象封装的是文件大概路线属性,不过不分包向(从)文件读(写)数据的点子。为了促成对文件的读和写操作供给学会科学的应用Java的IO成立对象。

字节流的画饼充饥基类:

    输入流:java.io.InputStream

    输出流:java.io.OutputStream

特点:

       字节流的架空中基地类派生出来的子类名称都是以其父类名作为子类名的后缀。

       如:FileInputStream, ByteArrayInputStream等。

说明:

       字节流管理的单元是多少个字节,用于操作2进制文件(Computer中持有文件都是2进制文件)

3.1. InputStream

案例:读取"c:/a.txt"文件中的全体剧情并在调控台呈现出来。

在意:事先希图叁个a.txt并置于c:/下,不要保存中文。

       a, 使用read()方法完结。

       b, 使用int read(byte[] b)方法达成。

写代码读取"c:/a.txt"文件中的全部的内容并在调控台显示出来

实现:

查看api文书档案(本身一定要起头)

InputStream 有read方法,二次读取三个字节,OutputStream的write方法叁遍写二个int。发现那八个类都以抽象类。意味着不能够创造对象,那么须要找到实际的子类来使用。

透过查看api文书档案,找到了FileInputStream类,该类便是大家体会Io流的一个输入流。

实现;显示指定文件内容。

明确使用流,使用哪一类流?使用输入流,FileInputStream

第一步:

1:打开流(即创建流)

第二步:

2:通过流读取内容

第三步:

3:用完后,关闭流资源

远近闻明流是Java中的一类对象,要开荒流其实便是开创具体流的对象,由于是读取硬盘上的文件,应该使用输入流。所以找到了InputStream类,不过InputStream是抽象类,需求选取它的求实完成类来创设对象便是FileInputStream。通过new 调用FileInputStream 的构造方法来创造对象。发现FileInputStream的构造方法需求内定文件的源于。查看构造方法,基本上能用字符串也能够承受File对象。大家经过营造File对象钦赐文件路径。

使用流就如使用水管一样,要展开将要关张。所以张开流和关闭流的动作是比不可少的。怎么着关闭流?使用close方法就可以,当成功流的读写时,应该经过调用close方法来关闭它,这几个方法会放出掉这两个点儿的操作系统财富.如若叁个应用程序张开了过多的流而没有关闭它们,那么系统能源将被耗尽.

    如何通过流读取内容?

招来api文书档案通过read方法,查看该办法,开采有再次来到值,并且是int类型的,该措施2回读取1个字节(byte)

 

三.一.一.    输入流读取措施1:

read方法()

贰回读取2个字节,读到文件末尾再次来到-1.

密切查阅api文书档案发掘read方法假使读到文件的末尾会重返-1。那么就可以通过read方法的重临值是或不是是-一来调控大家的轮回读取。

/**

     * 根据read方法返回值的特性,如果独到文件的末尾返回-1,如果不为-1就继续向下读。

     * */

private static void showContent(String path) throws IOException {

       // 打开流

       FileInputStream fis = new FileInputStream(path);

 

       int len = fis.read();

       while (len != -1) {

           System.out.print((char)len);

           len = fis.read();

 

       }

       // 使用完关闭流

       fis.close();

    }

 

咱俩习贯那样写:

/**

     * 根据read方法返回值的特性,如果独到文件的末尾返回-1,如果不为-1就继续向下读。

     * */

    private static void showContent(String path) throws IOException {

       // 打开流

       FileInputStream fis = new FileInputStream(path);

 

       int len;

       while ((len = fis.read()) != -1) {

           System.out.print((char) len);

       }

       // 使用完关闭流

       fis.close();

    }

三.一.二.    输入流读取措施二:

使用read(byte[] b) 方法。使用缓冲区(关键是缓冲区大小的明确)

使用read方法的时候,流必要读二次就管理三遍,能够将读到的数码装入到字节数组中,二回性的操作数组,可以升高功用。

难题一:缓冲区大大小小

那正是说字节数组如何定义?定义多大?

可以尝试开头化长度为5的byte数组。通过read方法,往byte数组中存内容

那就是说该read方法重临的是往数组中存了稍稍字节。

/**

     * 使用字节数组存储读到的数据

     * */

    private static void showContent2(String path) throws IOException {

       // 打开流

       FileInputStream fis = new FileInputStream(path);

 

       // 通过流读取内容

       byte[] byt = new byte[5];

       int len = fis.read(byt);

       for (int i = 0; i < byt.length; i ) {

           System.out.print((char) byt[i]);

       }

 

       // 使用完关闭流

       fis.close();

    }

问题1: 缓冲区太小:

    数据读取不完.

测试开采难点,由于数组太小,只装了几个字节。而文本的字节大于数组的长短。那么很确定可以将数组的长度定义大学一年级部分。比方10二五个。

/**

     * 使用字节数组存储读到的数据

     * */

    private static void showContent2(String path) throws IOException {

       // 打开流

       FileInputStream fis = new FileInputStream(path);

 

       // 通过流读取内容

       byte[] byt = new byte[1024];

       int len = fis.read(byt);

       for (int i = 0; i < byt.length; i ) {

           System.out.print(byt[i]);

       }

      

       // 使用完关闭流

       fis.close();

    }

主题材料三:缓冲区有私下认可值.

测试,打字与印刷的机能打字与印刷出了繁多0,因为数组数组有暗中认可初阶化值,所以,大家将数组的多寡总体都遍历和出来.以往亟待的是收取数组中的部分数据.供给将循环条件修改仔细翻看api文书档案。开掘该方法read(byte[] b)重回的是往数组中存入了稍稍个字节。就是数组实际存款和储蓄的多寡个数。

/**

     * 使用字节数组存储读到的数据

     * */

    private static void showContent2(String path) throws IOException {

       // 打开流

       FileInputStream fis = new FileInputStream(path);

 

       // 通过流读取内容

       byte[] byt = new byte[1024];

       int len = fis.read(byt);

       for (int i = 0; i <len; i ) {

           System.out.print(byt[i]);

    }

      

       // 使用完关闭流

       fis.close();

    }

总结:

标题一:为何打字与印刷的不是字母而是数字,

        是字母对应的码值。

        怎么样呈现字符,强转为char就能够

难点②:注意:回车和换行的主题素材。

        windows的转载和换行是"rn" 对应码表是13和十 。

3.1.三.    输入流读取措施3:

使用read(byte[] b,int off,int len)

查看api文档,

b鲜明是三个byte类型数组,当做容器来采纳

off,是点名从数组的怎么职位上马存字节

len,希望读多少个

实际就是把数组的1有的当做流的器皿来使用。告诉容器,从什么地方起初装要装多少。

/**

     * 把数组的一部分当做流的容器来使用

     * read(byte[] b,int off,int len)

     */

    private static void showContent3(String path) throws IOException {

       // 打开流

       FileInputStream fis = new FileInputStream(path);

 

       // 通过流读取内容

       byte[] byt = new byte[1024];

       // 从什么地方开始存读到的数据

       int start = 5;

      

       // 希望最多读多少个(如果是流的末尾,流中没有足够数据)

       int maxLen = 6;

 

       // 实际存放了多少个

       int len = fis.read(byt, start, maxLen);

 

       for (int i = start; i < start maxLen; i ) {

           System.out.print((char) byt[i]);

       }

 

       // 使用完关闭流

       fis.close();

    }

 

需求2:测试skip方法

通过Io流,读取"c:/a.txt"文件中的第七个字节到最终全数的从头到尾的经过并在调控台呈现出来。

剖析:其实就是要跳过文件中的1局地字节,需求搜索API文书档案。可以动用skip方法skip(long n),参数跟的是要跳过的字节数。

小编们要从第10个早先读,那么要跳过前几个就能够。

/**

     * skip方法

     *

     * */

    private static void showContent4(String path) throws IOException {

       // 打开流

       FileInputStream fis = new FileInputStream(path);

 

       // 通过流读取内容

       byte[] byt = new byte[1024];

       fis.skip(8);

       int len = fis.read(byt);

       System.out.println(len);

       System.out.println("**********");

       for (int i = 0; i < len; i ) {

           System.out.println((char) byt[i]);

       }

       // 使用完关闭流

       fis.close();

}

3.壹.四. 输入流读取措施4:

采纳缓冲(提升成效),并循环读取(读完全体剧情).

总括:读完文件的保有情节。很明显能够行使普通的read方法,3遍读三个字节直到读到文件末尾。为了进步功效能够采用read(byte[] byt);方法便是所谓的接纳缓冲进步效用。大家得以读取大文本数据测试(大于1K的文件文件.)

/**

     * 使用字节数组当缓冲

     * */

    private static void showContent5(String path) throws IOException {

       FileInputStream fis = new FileInputStream(path);

       byte[] byt = new byte[1024];

       int len = fis.read(byt);

       System.out.println(len);

       String buffer = new String(byt, 0, len);

       System.out.print(buffer);

    }

只顾:怎么着将字节数组转成字符串? 能够通过创立字符串对象就可以。

发现:一旦数据超越⑩2四个字节,数组就存款和储蓄不下。

何以将文件的剩余内容读完?

大家能够通过通过巡回保障文件读取完。

/**

     * 使用字节数组当缓冲

     * */

    private static void showContent7(String path) throws IOException {

       FileInputStream fis = new FileInputStream(path);

       byte[] byt = new byte[1024];

       int len = 0;

       while ((len = fis.read(byt)) != -1) {

           System.out.println(new String(byt, 0, len));

       }

    }

 

3.2. OutputStream

字节输出流

案例:

    一,写代码完结把"Hello World!"写到"c:/a.txt"文件中。

       a, c:/a.txt不存在时,测试一下。

       b, c:/a.txt存在时,也测试一下。

       要写八个本子:

       a, 使用write(int b) 实现。

       b, 使用write(byte[] b) 实现。

    二,在已存在的c:/a.txt文本文件中增添内容:“Java IO”。

明朗此时亟需向钦点文件中写入数据。

使用的正是能够操作文件的字节流对象。OutputStream。该类是抽象类,须要运用具体的兑现类来创立对象查看API文书档案,找到了OutputStream的贯彻类FileOutputStream 创造FileOutputStream 流对象,必须内定数量要存放的目标地。通过构造函数的样式。创立流对象时,调用了系统底层的资源。在内定地点树立了数额存放的指标文件。

流程:

    1:打开文件输出流,流的目的地是指定的文件  

    2:通过流向文件写数据

    3: 用完流后关闭流

三.二.1.    输出流写出办法壹:

选择write(int b)方法,3回写出叁个字节.

在C盘下创办a.txt文本文件

import java.io.FileOutputStream;

import java.io.IOException;

 

public class IoTest2 {

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

       String path = "c:\a.txt";

       writeTxtFile(path);

    }

 

    private static void writeTxtFile(String path) throws IOException {

       // 1:打开文件输出流,流的目的地是指定的文件

       FileOutputStream fos = new FileOutputStream(path);

 

       // 2:通过流向文件写数据

       fos.write('j');

       fos.write('a');

       fos.write('v');

       fos.write('a');

       // 3:用完流后关闭流

       fos.close();

 

    }

}

 

当c盘下的a.txt不设有会怎么?

测试:将c盘下的a.txt文件删除,开采当文件不存在时,会自行创设3个,不过创立不了多级目录。

留意:使用write(int b)方法,即使收纳的是int类型参数,不过write 的例行协定是:向输出流写入贰个字节。要写入的字节是参数 b 的多个未有。b 的 2四 个高位将被忽略。

三.二.二.    输出流写出方法二:

使用write(byte[] b),正是采取缓冲.进步功能.

上述案例中的使用了OutputStram 的write方法,叁遍只可以写1个字节。成功的向文件中写入了剧情。不过并不敏捷,如和升高成效呢?是不是合宜运用缓冲,依据字节输入流的缓冲原理,是或不是足以将数据保存中字节数组中。通过操作字节数组来进步效能。查找API文书档案,在OutputStram类中找到了write(byte[] b)方法,将 b.length 个字节从钦定的 byte 数组写入此输出流中。

如何将字节数据保存在字节数组中,以字符串为例,”hello , world” 如何转为字节数组。鲜明通过字符串的getBytes方法就可以。

public class IoTest2 {

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

       String path = "c:\a.txt";

       writeTxtFile(path);

    }

 

    private static void writeTxtFile(String path) throws IOException {

       // 1:打开文件输出流,流的目的地是指定的文件

       FileOutputStream fos = new FileOutputStream(path);

 

       // 2:通过流向文件写数据

       byte[] byt = "java".getBytes();

       fos.write(byt);

       // 3:用完流后关闭流

       fos.close();

    }

}

 

密切翻看a.txt文本文件发现上述顺序每运营1回,老的内容就可以被覆盖掉。,那么哪些不掩盖已有消息,可现在a.txt里扩充新闻呢。查看API文书档案,开采FileOutputStream类中的构造方法中有1个结构能够兑现追加的效果FileOutputStream(File file, boolean append)  第二个参数,append - 假使为 true,则将字节写入文件末尾处,而不是写入文件发轫处

private static void writeTxtFile(String path) throws IOException {

       // 1:打开文件输出流,流的目的地是指定的文件

       FileOutputStream fos = new FileOutputStream(path,true);

 

       // 2:通过流向文件写数据

       byte[] byt = "java".getBytes();

       fos.write(byt);

       // 3:用完流后关闭流

       fos.close();

    }

 

三.叁. 字节流文件拷贝

本文由新浦京81707con发布于首页,转载请注明出处:使用Intent传递对象

关键词: 新浦京81707con Java基础

上一篇:js日历选择控件,js日历控件

下一篇:没有了