标签：Java 04 System 线程 println new public out

1.Scanner

java.io包的PrintWriter类可用于以通常可读的形式（文本）写入输出数据。

java.util包的Scanner类用于从不同的源（例如输入流，用户，文件等）读取输入数据

 Scanner input = new Scanner(System.in);

        System.out.print("输入姓名: ");

        // 从键盘接收输入
        String name = input.nextLine();

2.自动装箱拆箱

Integer-转int

在拆箱中，Java编译器会自动将包装器类对象转换为其相应的原始类型

自动装箱，原始值会自动转换为Integer对象并存储在数组列表中

//自动装箱
      list.add(5);
      list.add(6);

      System.out.println("ArrayList: " + list);

      // 拆箱
      int a = list.get(0);

也就是类型转换

3.lambda表达式

功能接口 -单一函数 SAM

import java.lang.FunctionalInterface;
@FunctionalInterface
public interface MyInterface{
    //单一抽象方法
    double getValue();
}

Lambda表达式本质上是一个匿名或未命名的方法。lambda表达式不能单独执行。相反，它用于实现功能接口定义的方法。

(parameter list) -> lambda body
参数-主体

主体类型

单表达式 () -> System.out.println("Lambdas are great");

代码块

() -> {
    double pi = 3.1415;
    return pi;
};

lambda表达式不是单独执行的。相反，它形成了由功能接口定义的抽象方法的实现。

// GenericInterface.java
@FunctionalInterface
interface GenericInterface<T> {

    // 泛型方法
    T func(T t);
}

// GenericLambda.java
public class Main {

    public static void main( String[] args ) {

                //声明对GenericInterface的引用
                // GenericInterface对String数据进行操作
                //为其分配一个lambda表达式
        GenericInterface<String> reverse = (str) -> {

            String result = "";
            for (int i = str.length()-1; i >= 0 ; i--)
            result += str.charAt(i);
            return result;
        };

        System.out.println("Lambda reversed = " + reverse.func("Lambda"));

                //声明对GenericInterface的另一个引用
                // GenericInterface对整数数据进行操作
                //为其分配一个lambda表达式
        GenericInterface<Integer> factorial = (n) -> {

            int result = 1;
            for (int i = 1; i <= n; i++)
            result = i * result;
            return result;
        };

        System.out.println("5的阶乘 = " + factorial.func(5));
    }
}
Lambda reversed = adbmaL
5的阶乘 = 120

lambda与Stream API一

import java.util.ArrayList;
import java.util.List;

public class StreamMain {

    //使用ArrayList创建一个列表对象
    static List<String> places = new ArrayList<>();

    //准备我们的数据
    public static List getPlaces(){

        //将地点和国家添加到列表中
        places.add("Nepal, Kathmandu");
        places.add("Nepal, Pokhara");
        places.add("India, Delhi");
        places.add("USA, New York");
        places.add("Africa, Nigeria");

        return places;
    }

    public static void main( String[] args ) {

        List<String> myPlaces = getPlaces();
        System.out.println("Places from Nepal:");
        
        myPlaces.stream()
                .filter((p) -> p.startsWith("Nepal"))
                .map((p) -> p.toUpperCase())
                .sorted()
                .forEach((p) -> System.out.println(p));
    }

}

4.泛型

泛型有助于创建可与不同类型的对象（数据）一起使用的类，接口和方法。因此，允许我们重用我们的代码。

注意：泛型泛型不适用于基本类型（int，float，char等）。

class Main {
  public static void main(String[] args) {

    //用整数数据初始化泛型类
    GenericsClass<Integer> intObj = new GenericsClass<>(5);
    System.out.println("泛型类返回: " + intObj.getData());

    //用字符串数据初始化泛型类
    GenericsClass<String> stringObj = new GenericsClass<>("Java Programming");
    System.out.println("泛型类返回: " + stringObj.getData());
  }
}

class GenericsClass<T> {

  //T型变量
  private T data;

  public GenericsClass(T data) {
    this.data = data;
  }

  //返回T类型变量的方法
  public T getData() {
    return this.data;
  }
}

class GenericsClass<T> {...}

class Main {
  public static void main(String[] args) {

    //使用Integer数据初始化类
    DemoClass demo = new DemoClass();
    demo.<String>genericsMethod("Java Programming");
  }
}

class DemoClass {

  //泛型方法
  public <T> void genericsMethod(T data) {
    System.out.println("这是一个泛型方法。");
    System.out.println("传递给方法的数据是 " + data);
  }
}

集合框架使用Java中的泛型概念。例如，

// 创建一个字符串类型ArrayList
ArrayList<String> list1 = new ArrayList<>();

// 创建一个整数类型ArrayList
ArrayList<Integer> list2 = new ArrayList<>();

有界泛型

class GenericsClass <T extends Number>

    GenericsClass<String> obj = new GenericsClass<>();
    
    界限是Number--故此程序报错

5.File类

创建 -读取 -写入-删除

Java文件操作方法

操作方式	方法	包
创建文件	createNewFile()	java.io.File
读取文件	read()	java.io.FileReader
写入文件	write()	java.io.FileWriter
删除文件	delete()	java.io.File

例子

创建文件

 File file = new File("newFile.txt");
 //文件对象是文件或目录路径名的抽象表示
   boolean value = file.createNewFile();

读取文件

 使用FileReader创建的名为input的对象。现在，它已与input.txt文件链接。
 FileReader input = new FileReader("input.txt");
   input.read(array);

写入文件

 FileWriter output = new FileWriter("output.txt");

       //将字符串写入文件
       output.write(data);

删除文件

我们可以使用File类的delete()方法来删除指定的文件或目录。它返回

true - 如果文件被删除。
false - 如果文件不存在。

注意：我们只能删除空目录。

 //创建一个file对象
    File file = new File("file.txt");

    //删除该文件
    boolean value = file.delete();

其余用到在研究

6.包装类

8个基本类型中的每一个都有对应的包装器类。

原始类型	包装类
byte	Byte
boolean	Boolean
char	Character
double	Double
float	Float
int	Integer
long	Long
short	Short

Java包装类（Wrapper Classes）是一种将基本数据类型转换为对象的机制，它提供了一种将基本数据类型作为对象处理的方式。Java中的基本数据类型（如int、double、boolean等）是不具备对象特性的，无法直接参与面向对象编程中的各种操作，例如集合的存储、泛型的应用等。

Java包装类的主要作用包括：

将基本数据类型转换为对象：通过使用包装类，可以将基本数据类型转换为对应的对象，使其具有对象的特性，比如可以将int转换为Integer、double转换为Double等。
在集合中使用：Java集合类（如List、Set、Map等）只能存储对象，不能存储基本数据类型。因此，如果需要在集合中存储基本数据类型，就需要使用包装类将其转换为对象后再存储。
作为泛型类型参数：泛型不能使用基本数据类型作为类型参数，但可以使用包装类。这样可以在泛型中使用基本数据类型的值。
提供丰富的方法和操作：包装类提供了很多方法来操作基本数据类型的值，比如转换为字符串、比较大小、解析字符串等。

总的来说，Java包装类提供了一种将基本数据类型转换为对象的方式，使得基本数据类型也可以参与面向对象编程中的各种操作和功能。这样可以更灵活地处理基本数据类型，并在需要时转换为对象进行操作。

7.序列化

Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。

将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。

整个过程都是 Java 虚拟机(JVM)独立的，也就是说，在一个平台上序列化的对象可以在另一个完全不同的平台上反序列化该对象。

比如--对象-序列化JSON->发送->对方在反序列化得到原文

类 ObjectInputStream 和 ObjectOutputStream 是高层次的数据流，它们包含反序列化和序列化对象的方法。

bjectOutputStream 类包含很多写方法来写各种数据类型，但是一个特别的方法例外：

public final void writeObject(Object x) throws IOException

上面的方法序列化一个对象，并将它发送到输出流。相似的 ObjectInputStream 类包含如下反序列化一个对象的方法：

public final Object readObject() throws IOException, 
                                 ClassNotFoundException

该方法从流中取出下一个对象，并将对象反序列化。它的返回值为Object，因此，你需要将它转换成合适的数据类型。

public class Employee implements java.io.Serializable
{
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + name
                           + " " + address);
   }
}

一个类的对象要想序列化成功，必须满足两个条件：

该类必须实现 java.io.Serializable 接口。

该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的，则该属性必须注明是短暂的。

序列化

import java.io.*;
 
public class SerializeDemo
{
   public static void main(String [] args)
   {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      try
      {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      }catch(IOException i)
      {
          i.printStackTrace();
      }
   }
}

反序列化

mport java.io.*;
 
public class DeserializeDemo
{
   public static void main(String [] args)
   {
      Employee e = null;
      try
      {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      }catch(IOException i)
      {
         i.printStackTrace();
         return;
      }catch(ClassNotFoundException c)
      {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
    }
}

8.网络编程

网络编程->TCP/UDP--

Socket 编程：这是使用最广泛的网络概念，它已被解释地非常详细。

对于tcp和udp的详细再复习完毕后慢慢啃

// 文件名 GreetingServer.java
 
import java.net.*;
import java.io.*;
 
public class GreetingServer extends Thread
{
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException
   {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }
 
   public void run()
   {
      while(true)
      {
         try
         {
            System.out.println("等待远程连接，端口号为：" + serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            System.out.println("远程主机地址：" + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("谢谢连接我：" + server.getLocalSocketAddress() + "\nGoodbye!");
            server.close();
         }catch(SocketTimeoutException s)
         {
            System.out.println("Socket timed out!");
            break;
         }catch(IOException e)
         {
            e.printStackTrace();
            break;
         }
      }
   }
   public static void main(String [] args)
   {
      int port = Integer.parseInt(args[0]);
      try
      {
         Thread t = new GreetingServer(port);
         t.run();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

import java.net.*;
import java.io.*;
 
public class GreetingClient
{
   public static void main(String [] args)
   {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try
      {
         System.out.println("连接到主机：" + serverName + " ，端口号：" + port);
         Socket client = new Socket(serverName, port);
         System.out.println("远程主机地址：" + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);
 
         out.writeUTF("Hello from " + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);
         System.out.println("服务器响应： " + in.readUTF());
         client.close();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

9.Java多线程

图片.png

线程优先级

具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

--创建线程

Java 提供了三种创建线程的方法：

通过实现 Runnable 接口；

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

通过继承 Thread 类本身；

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

通过 Callable 和 Future 创建线程。

Thread 方法

序号	方法描述
1	public void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
2	public void run() 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
3	public final void setName(String name) 改变线程名称，使之与参数 name 相同。
4	public final void setPriority(int priority) 更改线程的优先级。
5	public final void setDaemon(boolean on) 将该线程标记为守护线程或用户线程。
6	public final void join(long millisec) 等待该线程终止的时间最长为 millis 毫秒。
7	public void interrupt() 中断线程。
8	public final boolean isAlive() 测试线程是否处于活动状态。

测试线程是否处于活动状态。上述方法是被Thread对象调用的。下面的方法是Thread类的静态方法。

序号	方法描述
1	public static void yield() 暂停当前正在执行的线程对象，并执行其他线程。
2	public static void sleep(long millisec) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
3	public static boolean holdsLock(Object x) 当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。
4	public static Thread currentThread() 返回对当前正在执行的线程对象的引用。
5	public static void dumpStack() 将当前线程的堆栈跟踪打印至标准错误流。

在多线程编程时，你需要了解以下几个概念：

线程同步
线程间通信
线程死锁
线程控制：挂起、停止和恢复

多线程使用

有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。

通过对多线程的使用，可以编写出非常高效的程序。不过请注意，如果你创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。

请记住，上下文的切换开销也很重要，如果你创建了太多的线程，CPU 花费在上下文的切换的时间将多于执行程序的时间！

总结

后续还需要了解的-网络编程-多线程

标签：Java,04,System,线程,println,new,public,out
From： https://www.cnblogs.com/Agtw/p/18090117

Java 04 杂

1.Scanner

2.自动装箱拆箱

3.lambda表达式

4.泛型

5.File类

6.包装类

7.序列化

8.网络编程

9.Java多线程

Thread 方法

总结

相关文章

赞助商

阅读排行

Java 04 杂

1.Scanner

2.自动装箱 拆箱

3.lambda表达式

4.泛型

5.File类

6.包装类

7.序列化

8.网络编程

9.Java多线程

Thread 方法

总结

相关文章

赞助商

阅读排行

2.自动装箱拆箱