Java基础-20-IO流2

最新推荐文章于 2022-09-10 20:03:59 发布
最新推荐文章于 2022-09-10 20:03:59 发布
阅读量373 收藏
点赞数
分类专栏： Java入门 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/faith_yee/article/details/44754779
版权

Java基础-IO流

IO流进阶2

1、IO流（File概述）

File类：

*用来将文件或者文件夹封装成对象
*方便对文件或文件夹属性信息进行操作
*File对象可以作为参数传递给流的构造函数
*了解File类中的常见方法

java.io.File File类：文件和目录路径名的抽象表示形式。 用户界面和操作系统使用与系统相关的路径名字符串 来命名文件和目录。

测试代码：

import java.io.*;
class FileDemo 
{
    public static void main(String[] args) 
    {
        consMethod();
    }

    //创建File对象
    public static void consMethod()
    {
        //将a.txt封装成File对象，可以将已有的和未出现的文件或者文件夹封装成对象
        File f1 = new File("a.txt");
        File f2 = new File ("d:\\abc","b.txt");
        File d = new File ("d:\\abc");
        File f3 = new File(d,"c.txt");
        System.out.println("f1:"+f1);
        System.out.println("f2:"+f2);
        System.out.println("f3:"+f3);
        File f4 = new File("d:"+File.separator+"d.txt");
        System.out.println("f4:"+f4);
    }
}

输出结果:

2、IO流（File对象功能-创建和删除）

File常见方法：创建、删除、判断、获取信息

（1）、创建 在指定位置创建文件，如果该文件已经存在，则不创建，返回false，和输出流不一样，输出流对象一建立创建文件，而且文件已经存在，会覆盖。

boolean creatNewFile();//当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
boolean mkdir();//创建此抽象路径名指定的目录。
boolean mkdirs();//创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。

（2）、删除

boolean delete();//删除此抽象路径名表示的文件或目录。失败返回false
void deleteOnExit();//在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。

3、IO流（File对象功能-判断）

（3）、判断

boolean exists();//测试此抽象路径名表示的文件或目录是否存在。
boolean isFile();//测试此抽象路径名表示的文件是否是一个标准文件。
boolean isDirectory();//测试此抽象路径名表示的文件是否是一个目录。
boolean isHidden();//测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute();//测试此抽象路径名是否为绝对路径名。

测试代码：

import java.io.*;
class FileDemo_1 
{
    public static void main(String[] args) throws IOException
    {
        Method_3();
        System.out.println();
        Method_2();
    }

    public static void Method_3() throws IOException
    {
        File f = new File("d:\\JAVADEMO\\day20\\FileCreatDemo.txt");
        f.createNewFile();
        f.mkdir();
        //记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在
        System.out.println("dir:"+f.isDirectory());
        System.out.println("file:"+f.isFile());
        System.out.println(f.isAbsolute());
    }
    public static void Method_2() throws IOException
    {
        File f = new File ("fileDemo.txt");
        System.out.println("exists:"+f.exists());
        System.out.println("execute:"+f.canExecute());
        //创建文件夹
        File dir = new File("abc\\kk\\a\\a\\dd\\ee\\qq\\aa");
        System.out.println("mkdir:"+dir.mkdirs());
    }
}

输出结果：

4、IO流（File对象功能-获取）

（4）、获取信息

String getName();//返回由此抽象路径名表示的文件或目录的名称。
String getPath();//将此抽象路径名转换为一个路径名字符串。
String getAbsolutePath();//返回此抽象路径名的绝对路径名字符串。
String getParent();// 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
long lastModified();//返回此抽象路径名表示的文件最后一次被修改的时间。
long length();//返回由此抽象路径名表示的文件的长度。

测试代码：

import java.io.*;
class FileDemo_2 
{
    public static void main(String[] args) throws IOException
    {
        Method_4();
        System.out.println();
        Method_5();

    }
    public static void Method_4()
    {
        File f = new File ("file.txt");
        System.out.println("path:"+f.getPath());
        System.out.println("abspath:"+f.getAbsolutePath());
        System.out.println("parent:"+f.getParent());
        //该方法返回的是绝对路径中的父目录，如果获取的是相对路径，返回null，如果相对路径中有
        //上一层目录，那么该目录就是返回结果
    }
    public static void Method_5()throws IOException
    {
        File f1 = new File("c:\\Test.java");
        File f2 = new File("d:\\hhaha.java");
        System.out.println("rename:"+f2.renameTo(f1));
        System.out.println("file+f2:"+f2.createNewFile());
        System.out.println("file+f1:"+f1.createNewFile());
    }
}

输出结果：

5、IO流（File对象功能-文件列表）

String [] list();//返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
static File[] listRoots();//列出可用的文件系统根。

测试代码：

import java.io.*;
class FileDemo_3 
{
    public static void main(String[] args) throws Exception
    {
        listDemo();
        listRootsDemo();
    }
    public static void listDemo()throws Exception
    {
        File f = new File("c:\\");
        String [] names = f.list();//调用list方法的file对象必须是封装了一个目录，该目录还必须存在。
        for(int x= 0;x<names.length;x++)
        {
            System.out.println(names[x]);
        }

    }
    public static void listRootsDemo()throws Exception
    {
        File[] files = File.listRoots();
        for(File f:files)
        {
            System.out.println(f);
        }
    }
}

输出结果：

6、IO流（File对象功能-文件列表2）

File [] listFiles();// 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
String [] list(FilenameFilter filter);//返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
接口FilenameFilter
boolean accept(File dir,String name);//测试指定文件是否应该包含在某一文件列表中。

Eg:

public boolean accept(File dir , String name)
{return name.endWith(".bmp");}

测试代码：

import java.io.*;
class FileDemo_4 
{
    public static void main(String[] args) throws Exception
    {
         Method_3();
         System.out.println("XXXXXXXXXXXXX");
         Method_4();
    }
    public static void Method_3()throws Exception
    {
        File dir = new File("C:\\");
        File []files = dir.listFiles();//获取当前目录下所有的文件的对象
        for(File f : files)
        {
            System.out.println(f.getName()+"::"+f.getPath());
        }
    }
    public static void Method_4()throws Exception
    {
        File dir = new File ("C:\\");
        String [] arr = dir.list(new FilenameFilter()
        {
            //匿名内部类
            public boolean accept(File dir,String name)
            {
                //System.out.println("XXXXXXXXXXXXX");
                return name.endsWith(".mp3");

            }
        });
        for(String filterFile:arr)
        {
            System.out.println(filterFile);
        }
    }
}

输出结果：

7、IO流（列出目录下所有的内容-递归）

列出指定目录下文件或者文件夹，包括子目录中的内容，也就是列出指定目录下的所有内容。

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可，在列出过程中出现的还是目录的话，还可以再次调用本功能，也就是函数自身调用自身。这种表现手法，或者编程手法，称为递归。

递归要注意：

（1）、限定条件。
（2）、要注意递归的次数，尽量避免内存溢出。

递归图例：

测试代码：

import java.io.*;
class FileDemo_5 
{
    public static void main(String[] args) throws Exception
    {
        File dir = new File("D:\\Program Files\\KWKGE");
        showDir(dir);
    }
    public static void showDir(File dir)throws Exception
    {
        System.out.println(dir);
        File [] files = dir.listFiles();
        for(int x = 0 ; x<files.length;x++)
        {
            if(files[x].isDirectory())
            {
                showDir(files[x]);
            }
            else
            {
                System.out.println(files[x]);
            }

        }
    }
}

输出结果：

8、IO流（列出目录下所有内容-带层次）

Demo

import java.io.*;
class FileDemo_6 
{
    public static void main(String[] args) throws Exception
    {
        File dir = new File("D:\\Program Files\\KWKGE");
        showDir(dir,0);
    }
    public static String getLevel(int level)throws Exception
    {
        StringBuilder sb = new StringBuilder();
        sb.append("|--");
        for(int x = 0;x<level;x++)
        {
            sb.insert(0,"     ");
        }
        return sb.toString();
    }
    public static void showDir(File dir,int level)throws Exception
    {
        System.out.println(getLevel(level)+dir.getName());
        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(getLevel(level)+files[x]);
            }
        }
    }
}

输出结果：

9、IO流（删除带内容的目录）

删除一个带内容的目录。图如下：

删除原理：在Windows中，删除目录从里面往外面删除的。既然从里面到外面删除。用递归。 测试代码：

import java.io.*;
class FileDemo_7 
{
    public static void main(String[] args) throws Exception
    {
        File dir = new File ("d:\\JAVATEST");
        removeDir(dir);
    }
    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]);
                System.out.println(files[x].toString()+"--file--:"+files[x].delete());
            }
            else
            {
                System.out.println(files[x].toString()+"--file--:"+files[x].delete());
            }
        }
    }   
}

输出结果：

10、IO流（创建java文件列表）

练习： 将一个指定目录下的java文件的绝对路径存储到一个文本文件中，建立一个java文件列表文件。

思路：

（1）、对指定的目录进行递归
（2）、获取递归过程所有的java文件的路径。
（3）、将这些路径存储到集合中。
（4）、将集合中的数据写入到一个文件中。

测试代码：

import java.util.*;
import java.io.*;
class FileDemo_8 
{
    public static void main(String[] args) throws Exception
    {
        File dir = new File("d:\\JAVADEMO");
        List<File> list = new ArrayList<File>();
        fileToList(dir,list);
        System.out.println(list.size());
        File file = new File("d:\\javaList.txt");
        writeToFile(list,file.toString());
    }
    public static void fileToList(File dir,List<File>list)
    {
        File[]files = dir.listFiles();
        for(File file : files)
        {
            if(file.isDirectory())
            {
                fileToList(file,list);
            }
            else
            {
                if((file.getName().endsWith(".java")))
                {
                    list.add(file);
                }

            }
        }
    }
    public static void writeToFile(List<File>list,String javaListFile)throws IOException//写到文件中
    {
        BufferedWriter bufw = null;
        try
        {
            bufw = new BufferedWriter(new FileWriter(javaListFile));
            for(File f : list)
            {
                String path = f.getAbsolutePath();
                bufw.write(path);
                bufw.newLine();
                bufw.flush();
            }
        }
        catch (IOException e)
        {
            throw e;

        }
        finally
        {
            try
            {
                if(bufw!=null)
                {
                    bufw.close();
                }
            }
            catch (IOException e)
            {
                throw e;
            }   
        }
    }
}

输出结果：

11、IO流（Properties简述）

java.util.Properties Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 Properties是hashtable的子类，也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串。是集合中和IO技术相结合的集合容器，该对象的特点：可以用于键值对形式的配置文件。那么在加载数据时，需要数据有固定形式：键=值

12、IO流（Properties存取）

Object setProperty(String key,String value);//调用 Hashtable 的方法 put。
String getProperty(String key);//用指定的键在此属性列表中搜索属性。
Set <String> StringPropertyNames();//返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。

测试代码：

import java.io.*;
import java.util.*;
class PropertiesDemo
{
    public static void main(String []args)
    {
        Properties prop = new Properties();
        prop.setProperty("zhangsan","30");
        prop.setProperty("lisi","39");
        System.out.println(prop);

        String value = prop.getProperty("lisi");
        System.out.println(value);

        prop.setProperty("lisi",89+" ");
        value = prop.getProperty("lisi");
        System.out.println(value);

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

输出结果：

13、IO流（存取配置文件）

void list(PrintStream out);//将属性列表输出到指定的输出流。
void list(PrintWriter out);// 将属性列表输出到指定的输出流。
void load(InputStream inStream);//从输入流中读取属性列表（键和元素对）。
void load(Reader reader);//按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
void store(OutputStream out ,String comments);//以适合使用 load(InputStream) 方法加载到Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
void store(Writer writer,String comments);//以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。

测试代码：

import java.io.*;
import java.util.*;
class PropertiesDemo_1
{
    public static void main(String []args)throws IOException
    {
        loadDemo();
        //method_1();
    }
    public static void loadDemo()throws IOException
    {
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream("D:\\JAVADEMO\\day20\\info.txt");

        //将流中的数据加载进Properties的对象中
        prop.load(fis);

        prop.setProperty("wangwu","30");
        //以上修改了内容，可是修改了以后只是在内存中的数值，没存到数据流中。所以
        FileOutputStream fos = new FileOutputStream("info.txt");

        prop.store(fos,"haha");
        System.out.println(prop);

        prop.list(System.out);
        fos.close();
        fis.close();
    }
}

输出结果：

演示：如何将流中的数据存储到集合中，想要将config.ini中键值数据存到集合中进行操作。 思路：

（1）、用一个流和info.txt文件关联
（2）、读取一行数据，将该行数据用“=”进行切割
（3）、等号左边作为键，右边作为值，存入到Properties集合即可。

源文件：

测试代码：

import java.io.*;
import java.util.*;
class PropertiesDemo_2
{
    public static void main(String []args)throws IOException
    {
        method_1();
    }
    public static void method_1()throws IOException
    {
        BufferedReader bufr = new BufferedReader(new FileReader("D:\\eclipse\\configuration\\config.ini"));
        String line = null;
        Properties prop = new Properties();

        while((line = bufr.readLine())!=null)
        {
            String[] arr = line.split("=");
            System.out.println(arr[0]+"......"+arr[1]);
            prop.setProperty(arr[0],arr[1]);
        }
        bufr.close();
        System.out.println(prop);
    }
}

输出：

14、IO流（Properties练习）

用于记录应用程序运行次数 如果使用次数已到，那么给出注册提示

很容易想到的是计数器 可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。 可是随着该应用程序的退出，该计数器也在内存中消失了。

下一次在启动该程序，又重新开始从0计数。这样不是我们想要的。

程序即使结束，该计数器的值也存在。下次程序启动会先加载该计数器的值并加1后再重新存储起来。所以要建立一个配置文件，用于记录该软件的使用次数。

该配置文件使用键值的形式，这样便于阅读数据，并操作数据。

键值对数据是map集合。数据是以文件形式存储，使用io技术。

那map+io--------------->properties

配置文件可以实现应用程序数据的共享。

测试代码：

import java.io.*;
import java.util.*;
class  RunCount
{
    public static void main(String[] args)throws IOException 
    {
        Properties prop = new Properties();
        File file = new File("D:\\JAVADEMO\\day20\\count.ini");
        if(!file.exists())
        {
            file.createNewFile();
        }
        FileInputStream fis = new FileInputStream(file);
        prop.load(fis);
        int count = 0;
        String value = prop.getProperty("time");
        if(value!= null)
        {
            count = Integer.parseInt(value);
            if(count >= 5)
            {
                System.out.println("您好，使用次数已到。拿钱！");
                return;
            }
        }
        count++;
        prop.setProperty("time",count+" ");
        FileOutputStream fos = new FileOutputStream(file);
        prop.store(fos,"haha");
        fos.close();
        fis.close();
    }
}

输出结果：

15、IO流（PrintWriter）

打印流：该流提供了打印方法，可以将各种数据类型的数据都原样打印。

字节打印流：PrintStream，构造函数可以接收的参数类型

（1）、file对象，File
（2）、字符串路径。String
（3）、字节输出流。OutputStream

字符打印流：PrintWriter，构造函数可以接收的参数类型

（1）、file对象，File
（2）、字符串路径：String
（3）、字节输出流：OutputStream
（4）、字符输出流：Writer

测试代码：

import java.io.*;
import java.util.*;

class PrintStreamDemo
{
    public static void main()throws IOException
    {
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

        PrintWriter out = new PrintWriter(System.out);//字符打印流

        String line = null;
        while((line = bufr.readLine())!=null)
        {
            if("over".equals(line));
            {
                break;
            }
            out.println(line.toUpperCase());
            out.flush();//要等所有都输入完毕才能释放完，如果不想这样，可以这样：
            //PrintWriter out = new PrintWriter(System.out，true);
            //表示自动释放流
        }
        out.close();
        bufr.close();
    }
}

16、IO流（合并流）

类SequenceInputStream（序列流），对多个流进行合并并操作。

测试代码：

import java.io.*;
import java.util.*;
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();
    }
}

输出结果：

faith_yee
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础-----IO流
qq_48788523的博客
12-09 951
Java中的IO笔记,很全,为了复习IO知识而生
Java基础---IO流
我是太阳
01-30 2万+
1、File类的使用 常用构造器 路径分隔符 常用方法 2、IO流原理及流的分类 3、节点流(或文件流) 4、缓冲流 5、转换流 6、标准输入、输出流 7、 打印流 8、数据流 9、对象流 10、随机存取文件流 11、Path、Paths、Files类的使用 ...
JavaSE IO流
choujuan1372的博客
07-27 61
1.文件操作： 在Java中如何操作磁盘中文件，java中把文件作为一个对象进行操作 File类进行表示磁盘中的文件: 路径: 绝对路径：从磁盘的根目录进行表示 如：E:\vedio\20170713\JavaSE\T_day01\question\...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
JAVA基础-----IO流基本概念
我在人间找bug
11-19 1152
带你走进 JAVA 里面 IO 流的世界。
Java基础 -- 呕心沥血的JavaIO流篇笔记
wanghuichen的博客
06-13 2067
呕心沥血的javaio流篇笔记（内含代码练习）
Java-详解IO流原理及流的分类
weixin_52533007的博客
06-01 2671
Java IO原理 一、概述 （1）I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。 输入input：读取外部数据（磁 盘、光盘等存储设备的数据）到程序（内存）中。 输出output：将程序（内存）数据输出到磁盘、光盘等存储设 备中。 （2）Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。 （3） java.io包下提供了各种“流”类和接口，用以获取不同种 这里是引用 类的数据，并通过
Java基础进阶IO流-文件复制
qq_46096136的博客
09-10 6665
【代码】Java基础进阶IO流-文件复制。
Java基础系列35-IO流
只是甲的博客
09-16 2万+
文章目录一.IO流概述二. 字节流2.1 FOS与FIS2.2 FOS写数据的三种方式2.3 FOS如何实现换行和追加写数据2.4 FOS写数据加入异常处理2.5 FIS读数据方式1一次读取一个字节2.6 FIS读数据方式2一次读取一个字节数组2.7 字节流练习之复制文本文件2.8 字节流练习之复制图片三. 字节缓冲区流3.1 概述3.2 四种方式复制图片效率测试四. 转换流4.1 什么是编码表4.2 String类的编解码4.3 字符流Stream的编解码(写入文件)五. 字符流5.1 复制Java文件5
第一章 java 基础 - 08.IO输入流与输出流
yancyang的博客
09-26 4528
无意间都到一篇《走心的安卓工程师跳槽经验分享》，发现自己工作几年了，技术方面虽然有了飞跃的进步，可是不知道自己的技术到了什么地步，每个方面我都涉及到了，但都不深，这大概是初级工程师的诟病吧！ 即使知道也不知道从何下手，非常感谢《走心的安卓工程师跳槽经验分享》的作者！ 感兴趣的朋友和我一起走下去吧！ 08.IO输入流与输出流 java的核心库java.io提供了全面的IO接口。包括：文件读写、标准设...
java-网络编程-io流-学习案例
02-25
在本学习案例中，我们关注的是Java的IO流和Socket技术，这些是实现客户端-服务器通信的基础。IO流用于数据的输入输出操作，而Socket则是网络通信的桥梁。 首先，让我们深入了解Java的IO流。IO流在Java中被广泛用于...
大学课程讲义-Java基础-IO
最新发布
08-14
Java 的 IO 流主要包括输入、输出两种 IO 流，每种输入、输出流有可分为字节流和字符流两大类。字节流以字节为单位来处理输入、输出操作，字符流以字符为单位来处理输入、输出操作。 ### IO 概述 IO 流是指 Java ...
Java-IO流/Stream流总结
07-12
Java的IO流与Stream流是Java程序中处理输入输出的核心技术。IO流主要分为字节流和字符流，这两种流分别处理二进制数据（如图片、音频等）和文本数据（如ASCII、UTF-8编码的文本）。下面将详细阐述这两个流的分类、...
Java-Io流，练习
07-06
本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO流的概念 IO流在Java中分为两大类：输入流（Input Stream）和输出流（Output Stream）。输入流用于从源（如文件、网络连接等）读取数据，而输出流则...
Java核心基础编程精讲-IO流
06-21
其核心基础编程是每个Java开发者必备的知识，而IO流则是其中至关重要的一部分。IO流（Input/Output Stream）是Java提供的一种处理输入输出数据的方式，它使得程序能够进行高效的数据传输，包括读取文件、网络通信、...
交通灯管理系统
faith_yee的专栏
03-30 1407
交通灯管理系统 交通灯管理系统详讲 模拟实现十字路口的交通灯管理系统逻辑，具体需求如下： *异步随机生成按照各个路线行驶的车辆。 例如： 由南向而来去往北向的车辆 ---- 直行车辆 由西向而来去往南向的车辆 ---- 右转车辆 由东向而来去往南向的车辆 ---- 左转车辆 ...... *信号灯忽略黄灯，只考虑红灯和绿灯。 *应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。
Java基础-03-java流程控制、函数及内存结构
faith_yee的专栏
03-30 564
Java基础 编程基础 1、程序流程控制 （1）、三元运算符 (x>y)?z:m; Eg: y = (x>1)?100:200; //若x>1则把100赋给y,否则把200赋给y三元运算符的特点：可以简化代码，但必须有一个结果。 （2）、选择结构 注意：if和switch都很像，但具体什么场景下，应用哪种语句呢？ 如果判断
银行业务调度系统
faith_yee的专栏
03-30 562
银行业务调度系统 银行业务调度系统详解 模拟实现银行业务调度系统逻辑，具体需求如下： *银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。 *有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。 *异步随机生成各种类型的客户，生成各类型用户的概率比例为： *VIP客户 ：普通客户 ：快速客户 = 1
Java基础-24-网络编程2
faith_yee的专栏
03-30 539
Java基础-网络编程 网络编程2 1、网络编程（TCP-上传图片） 需求：上传图片 客户端： （1）、服务端点 （2）、读取客户端已有的图片数据。 （3）、通过socket输出流将数据发给服务端 （4）、读取服务端反馈信息。 （5）、关闭资源。 测试代码： import java.io.*; import java.net.*; class PicClient {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值