Java 学习第一天

最新推荐文章于 2021-01-15 11:20:56 发布

__计算机小白__

最新推荐文章于 2021-01-15 11:20:56 发布

阅读量215

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/qq_22527639/article/details/81478643

版权

Java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java毕竟那么多人用，虽然觉得编程语言只是一个工具罢了，不过还是得花点精神学的。这个暑假还有将近三周，之前有了C++的知识学起来应该比较快。所以就用些文章记录一些遇到的问题什么的吧，那些基础的就没有必要写了。

在Java中 String类声明后就不能够改变了，除非新声明一个。不过在Java中有StringBuffer类。和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuffer 方法

以下是 StringBuffer 类支持的主要方法：

序号	方法描述
1	public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2	public StringBuffer reverse() 将此字符序列用其反转形式取代。
3	public delete(int start, int end)前闭后开移除此序列的子字符串中的字符。
4	public insert(int offset, String str) 将 `int` 参数的字符串表示形式插入此序列中。
5	replace(int start, int end, String str) 使用给定 `String` 中的字符替换此序列的子字符串中的字符。

delete:

package first;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");

        StringBuffer str = new StringBuffer();
        str.append("My ");
        str.append("name is ");
        str.append("Lym");
        System.out.printf("Hello,%s\n",str);
        str.delete(0,2);
        System.out.printf("Hello,%s\n",str);
    }
}



Hello World
Hello,My name is Lym
Hello, name is Lym

其他的String类的方法和也基本上可以用的。

insert:

package first;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");

        StringBuffer str = new StringBuffer();
        str.append("My ");
        str.append("name is ");
        str.append("Lym");
        System.out.printf("Hello,%s\n",str);
        str.delete(0,2);
        System.out.printf("Hello,%s\n",str);
        str.insert(0,"My");
        System.out.printf("Hello,%s\n",str);

    }
}

Hello World
Hello,My name is Lym
Hello, name is Lym
Hello,My name is Lym

初始化String类对象的数组的时候就不用再另外说有多少个了，除非是不知道。

String str[] = {"Hello","My","Name"};

这样初始化就好了。循环可以用传统的循环也可以用foreach循环，就是迭代整个数组里的东西。

也就是可以这样用

 String str[] = {"Hello","My","Name"};

        for(String str_temp:str)
        {
            System.out.println(str_temp);
        }

结果：

Hello
My
Name

哇，java和C++还是有不一样的，Java在跟Main同一个类写一个函数前面要加上public static才可以。

package first;

public class HelloWorld
{

    public static void main(String[] args)
    {

       String str[] = {"Hello","My","Name"};

       str_print(str);
    }

    public static void str_print(String[] list)
    {
        for(String str_temp:list)
        {
            System.out.println(str_temp);
        }

    }


}

数组也不能像以前愉快的直接int a[10]就可以了，一定要int[] a = new int[10]才可以

从别的地方看来的：

创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

一、使用 dataType[arraySize] 创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

另外，你还可以使用如下的方式创建数组。

dataType[] arrayRefVar = {value0, value1, ..., valuek};

package first;

import java.util.Arrays;

public class HelloWorld
{

    public static void main(String[] args)
    {

        double[] a = new double[10];
        for(int i=0;i<10;i++)
        {
            a[i] = Math.random();//赋值随机数
        }
        Arrays.sort(a);//排序
        for(int i=0;i<10;i++)
        {
            System.out.println(a[i]);
        }


    }



}

就像Math类一样,Arrays类也提供了许多好用的函数，使用的方法也是Arrays.sort(...)这样的，上面的就是一个升序排序的功能。

Arrays 类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

具体说明请查看下表：

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

越来越感觉到Java的面向对象的思想了，比C++还面向对象，基本上把函数都写在一个类里，还美其名曰叫接口。

Java获取当前时间：

首先要先引入包

import java.util.Date;

package first;

import java.util.Date;

public class HelloWorld
{

    public static void main(String[] args)
    {

        Date date = new Date();
        System.out.println(date.toString());


    }



}

结果：
Tue Aug 07 14:27:50 CST 2018

Process finished with exit code 0

构造函数啥的和C++ 感觉是一样的。试试看

package first;

public class HelloWorld
{

    public static void main(String[] args)
    {

        dog dog1 = new dog(7);
        dog1.print_age();



    }



}

class dog{
    //构造函数，用类名作为函数名
    dog(int i){
        age = i;

    }
    public void  print_age() {
        System.out.println("Age is "+age);
    }

    private int age;
}

结果：

Age is 7

Process finished with exit code 0

Java的方法使用中还有个比较奇特的方法，就是可变参数

可变参数

JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。

方法的可变参数的声明如下所示：


typeName... parameterName

在方法声明中，在指定参数类型后加一个省略号(...) 。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

package first;

public class HelloWorld
{

    public static void main(String[] args)
    {

        // 调用可变参数的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});

    }

    public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }

        double result = numbers[0];

        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }


}

结果：


The max value is 56.5
The max value is 3.0

Process finished with exit code 0

接下来讲讲这个可变参数干嘛用的

我们在编写方法的过程中，可能会遇见一个方法有不确定参数个数的情况。一般我们会用方法重载来解决问题：

但是当参数多的时候就会显得很繁琐，同时每次扩展都会很麻烦。于是我们可以使用数组作为参数：

But，这样还是有个准备参数的过程（还要构造一个数组，麻烦啊）。于是我们可以使用不定项参数（可变参数）的方式：

这样做就可以解决参数个数不确定的问题。

假如定义一个函数：

 public void method(int...args);

public static void main(String[] args){
    method();
    method(null);
    method(1,2);
    method(1,2,3);
    method(1,2,3,4,5,6,7,8,9);        //不同的参数个数，但是调用的都是同一个method方法
}

下面这几种都是可以的，就不需要重载了。

int...args的参数形式能实现不定项参数实质上是因为变量args是一个数组，所以，不定项参数可以理解为数组。

注意事项：

1）不定项参数必须放在参数列表最后一个。

2）不定项参数只能有一个（多个，必然有一个不是最后一个）。

3）重载时，运行优先级问题。

不过，有时候还是得用到重载，传参相当于传数组，那我还不如直接传数组。。到时候看看哪种更好用吧，，感觉重载用的范围会更大。

Java 流(Stream)、文件(File)和IO

之前学C++的时候是在控制台下面跑的程序，稍微后面点就用QT 了。Java的这个不是，所以如果我们要从控制台获取字符或者字符串要怎么办呢。

从控制台读取多字符输入

读取控制台输入

Java 的控制台输入由 System.in 完成。

为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。

下面是创建 BufferedReader 的基本语法：


BufferedReader br = new BufferedReader(new 
                      InputStreamReader(System.in));

从 BufferedReader 对象读取一个字符要使用 read() 方法，它的语法如下：


int read( ) throws IOException

package first;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class HelloWorld
{

    public static void main(String[] args) throws IOException {
        char c;
        // 使用 System.in 创建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("输入字符, 按下 'q' 键退出。");
        // 读取字符
        do {
            c = (char)br.read();
            System.out.println(c);
        } while (c != 'q');

    }



}

读取字符串：

package first;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class HelloWorld
{

    public static void main(String[] args) throws IOException {
        String c;
        // 使用 System.in 创建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("输入字符, 输入'end'退出。");
        // 读取字符
        do {
            c = (String) br.readLine();
            System.out.println(c);
        } while (!c.equals("end"));

    }



}

文件保存读取

前面用了保存字节的方法，可是保存的不好读取，还是用这样的好用。

package first;

import java.io.*;

public class HelloWorld
{

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

        File f = new File("hello.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 构建FileOutputStream对象,文件不存在会自动新建

        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk

        writer.append("中文输入");
        // 写入到缓冲区

        writer.append("\r\n");
        // 换行

        writer.append("English");
        // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入

        writer.close();
        // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉

        fop.close();
        // 关闭输出流,释放系统资源

        FileInputStream fip = new FileInputStream(f);
        // 构建FileInputStream对象

        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 构建InputStreamReader对象,编码与写入相同

        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
            sb.append((char) reader.read());
            // 转成char加到StringBuffer对象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流

        fip.close();
        // 关闭输入流,释放系统资源


    }



}

__计算机小白__

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 学习第一天

Java毕竟那么多人用，虽然觉得编程语言只是一个工具罢了，不过还是得花点精神学的。这个暑假还有将近三周，之前有了C++的知识学起来应该比较快。所以就用些文章记录一些遇到的问题什么的吧，那些基础的就没有必要写了。在Java中 String类声明后就不能够改变了，除非新声明一个。不过在Java中有StringBuffer类。和 String 类不同的是，StringBuffer 和 Stri...
复制链接

扫一扫

专栏目录