成都网站建设设计

将想法与焦点和您一起共享

Java入门知识以及细节(1.3w字笔记)-创新互联

欢迎来到我的主页:【一只认真写代码的程序猿】

创新互联专注于绩溪企业网站建设,成都响应式网站建设公司,商城系统网站开发。绩溪网站建设公司,为绩溪等地区提供建站服务。全流程定制制作,专业设计,全程项目跟踪,创新互联专业和态度为您提供的服务

本篇文章收录于专栏【Java入门学习】

如果这篇文章对你有帮助,希望点赞收藏加关注啦~

目录

Java和C的区别

Java中的运算

Math.random()函数

跳出多重循环的两种break方法

数组中的使用以及Java中的可扩展性

数组成员length

可扩展性 

数组中的new int [n]

数组变量间的比较

数组的拷贝以及对应元素的比较

数组的一些计算以及for-each循环

题1:计算某个数字输入了多少次。

题2:数组中的线性搜索(最笨的方法)

For-Each循环

题3:素数

字符类型

Math类

字符串

字符串的创建与连接

字符串的输入

字符串的比较

对字符串操作

字符串比大小comparTo

获取字符串长度length()

访问字符串里的单个字符

得到字符串的子串

寻找某个字符

其他String操作



Java和C的区别
  • C是面向过程,按行执行;Java是面向对象,按模块执行。
  • 面向过程(Procedure Oriented):要实现一件事情,首先将事情拆分成多个步骤,然后按照一定的顺序执行。
    面向对象(Object Oriented ):首先将事物抽象成对象的概念,然后给对象赋予属性和方法,接着让每个对象去执行他们自己的方法。
  • 单文件的编译时间Java更快。

  • C语言可以直接操作内存,java不能。

  • C语言可以封装动态库,java不能

  • C语言不容易跨平台,java容易实现跨平台。
    Java只需要编译一次,就可以在不同的平台上面运行,但是C如果在windows系统上编译生成的文件只能在windows上运行,如果在Linux需要重新编译。

  • 举个栗子,买电脑
    面向过程实现:我要买一台电脑-->我要了解我需要什么样的电脑-->了解电脑的各个参数-->去实体店里买电脑-->砍价-->买到电脑
    面向对象实现:我要买电脑-->找个人帮我买-->他买好之后回来给我了

  • 面向对象的优点:

    易维护、质量高、效率高、思考方式接近于生活、易扩展。

  • 三大特性
    封装:将对象的属性和操作合并成一个独立的整体,同时会尽量隐藏对象的内部细节。继承:从a类中派生出b类,b类能吸收a类的数据属性和行为并扩展出新的能力。
    多态:同一个行为,具有多个不同的表现形式。也就是同一个接口,可以用不同的实例进而执行不同操作。

  • C语言中变量未初始化会赋随机值,Java中未初始化则无法编译


Java中的运算

Java中的关系运算(6个): 相等== 不相等!= 大于>小于< 大于等于>= 小于等于<=
关系运算符的优先级低于算术运算符,但是比赋值运算符要高

关系运算符中的==和!=的优先级比其他关系运算符要低


C语言中一般用1或0表示真假,Java中一般用true or false

  • true或false没有谁大谁小之分,二者不可以和数字进行比较
  • 7>=3+4,先算3+4,再算7>=7 
  • 5>3==6>4 先算5>3得到true,6>4得到true,最后:true == true 
  • 6>5>4 先做6>5,得到true,再做true>4 无法比较
  • a==b==true 先做a==b,得到true or false,再判断是否等于true
  • a==b==6 先做a==b,得到true或false,再判断是否等于6,无法判断
  • a==b>false 先做b>false,不管b是什么,都无法比较 (a==b)>false,但是前面得出true或false,也无法与false比较大小
  • System.out.println(5==5.0);//输出true
  • 两个浮点数比较

判断两个浮点数是否相等,求出差值的绝对值,该绝对值要小于一个很小的数字。

public class compare {
    public static void main(String[] args) {
        System.out.println(5==5.0);
        //整数和浮点数比较得到true

        //两个浮点数呢?
        double a = 1.0;
        double b = 0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1;
        System.out.println("a为" + a + " b为" + b);
        System.out.println(a==b);//得到false

        //判断两个浮点数是否相等:>先求差值绝对值,和一个比较小的数字比较
        System.out.println(Math.abs(a-b)< 1e-6);//得到true
 

   }
}

  • 保留小数(使用printf)
System.out.printf("%.2f\n",3.356);//输出3.36

Math.random()函数

函数介绍

Math.random()可以随机生成大于等于0.0且小于1.0的伪随机值,类型是double

随机生成数字或字符

随机生成0到n的数

int num=(int)(Math.random()*n); 

随机生成a到b的数

int number=m+(int)(Matn.randon()*b + a); 

随机生成char1到char2的字符

char c = (char)(cha1+Math.random()*(cha2-cha1+1));

//猜数游戏
public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        int x = (int)(Math.random()*100+1); //数字在[1 , 100]
        System.out.println("请猜数:>");

        int num;
        int count=0;

        do{
            num=in.nextInt();
            count++;
            if(num>x) System.out.println("猜大了!");
            else if(num

跳出多重循环的两种break方法

在想要跳出的循环前面加上标签,之后break跳出时直接跳过标签下的循环。

标签后要加冒号(以下代码中的标签是OUT)

ps:类似于C语言中的goto语句

实现跳出3-3-3层循环(后面的循环不再执行)

public static void main(String[] args) {
        int i=0;
        int j=0;
        int n=0;
        OUT:
        for(i = 0; i< 5; i++) {
            System.out.println("一层循环第" + i + "次");
            for(j = 0; j< 5; j++) {
                System.out.println("二层循环第 " + i + "-" + j + " 次");
                for(n = 0;n< 5; n++)
                {
                    System.out.println("三层循环第 " + i + "-" + j + "-" + n + "次");
                    if(i==3&&j==3&&n==3)
                    {
                        System.out.println("跳出3-3-3循环");
                        break OUT;
                    }
                }
            }
        }
        System.out.println("结束");
}

通过外层循环增加判断条件,内层循环修改判断条件的值来跳出循环

如下代码中的flag

由于flag只会使用到两个值,所以考虑用boolean类型,它只有true和false这两个值。

public static void main(String[] args) {
            int i=0;
            int j=0;
            int n=0;
            boolean flag =true;

            //在最外层循环中增加一个flag是否为true的判断条件
            for(i = 0; i< 5 && flag; i++) {
                System.out.println("一层循环第" + i + "次");
                for(j = 0; j< 5; j++) {
                    System.out.println("二层循环第 " + i + "-" + j + " 次");
                    for(n = 0;n< 5; n++)
                    {
                        System.out.println("三层循环第 " + i + "-" + j + "-" + n + "次");
                        if(i==3&&j==3&&n==3)
                        {
                            System.out.println("跳出3-3-3循环");
                            flag = false;
                            break;
                        }
                    }
                }
            }
            System.out.println("结束");
}

的确跳出了3-3-3的循环,但是后面的循环依旧在执行。所以如果要跳出整个大循环,应该都加上一个flag的判断条件。

for( i=0 ; i<5 && flag; i++){

  for( j=0 ; j<5 && flag; j++){

  for(n=0 ; n<5 &&flag; n++){

  if( i==3&&j==3&&n==3){

  System.out.println("跳出3-3-3循环");

  flag=false;

  break;

  }

  }

  }

  }



数组中的使用以及Java中的可扩展性 数组成员length

在Java中,数组的元素个数是可以改变的;而在C语言中数组元素个数一般是固定的,要改变元素个数需要进行内存分配。

在Java中,每一个数组都有一个内部成员length,它可以告诉你数组元素个数。

格式:数组名.length

求数组中大于平均值的数:>

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("要输入多少数字:>");
        int cnt=in.nextInt();
        int [] numbers=new int[cnt];
        double sum=0.0;
        for(int i=0;iaverage)
            {
                System.out.println(numbers[i]);
            }
        }
}
可扩展性 

这样的程序有可扩展性

也就是指:不需要修改这个for循环,与数组名、元素个数等无关,这个程序可以用于其他代码中。

如下代码中,数组的内容不影响for循环的进行。

由于length的存在,无论数组内容如何变化,都能将各个元素输出。

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        int []arr={1,2,3,4,5,6};
//从这里之后的代码都与arr元素内容无关了
        System.out.println("数组元素有"+arr.length+"个");
        for(int i=0;i

可扩展性高就是指:
当你要添加新的内容时,不需要对程序中的其他内容进行修改。
也就是说新的功能可以很容易地加入到程序中去。比如说在过程中需要增加新的功能时,这个项目的主结构不变,这就是可扩展性高。

数组中的new int [n]

先看一段代码:>

在改变数组b的同时,数组a也发生了变化

原因:只有一个new int [5]的数组,而a和b都只是管理这块空间。

如下图:>

int i =5;是将5这个值赋给一个整型变量i,i拥有这个数值5

而 int []a=new int [5];

是指 创建出了一块数组,属于new int [5],而数组a可以管理这个new数组。

而int []b=a;

是指 让b也拥有这块空间的管理权,数组b也可以管理这个数组。

举个栗子:有一块公共的空地,叫做new int [],

有一天,地主a在这块地上的第一块空间内种了5棵树;

后来,邻居b想在第一块空间内种6棵树,于是把a的5棵树砍了,种好了自己的6棵树.

在数组内放的数据与数值大小无关,只和存放的先后有关。

(先有数组,占一块空间,后来的a和b都只是管理这个数组)

(谁最后在这里种树,这片区域的树就有几棵)

为了加深理解,看以下代码:>

请问a1的各个值为多少?

所以,在java中可以通过a2改变a1中数组各元素大小。

因为数组并不归谁所有,a1和a2都只是负责使用这一块区域;甚至可以有a3、a4....

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        int []a1= {1,1,1};
        int[] a2=a1;
        for(int i=0;i");
        for(int i=0;i

数组变量间的比较

数组变量间进行比较,判断的是:是否管理同一个数组。(不仅仅是内容相同)

解释:

1、false 虽然a1和a2的内容相同,但是二者的数组所占的位置不同,不是同一块空间。

2、true 由于a3=a1,将管理权分给a3;a1和a3管理同一片区域。

3、false 由于a3管理的是a1管理的空间,这就相当于是比较a1和a2了,当然不相等。 

小总结:

1、数组变量是数组的管理者,而不是数组本身。

2、我们先是创建出了一个数组,如何可以将这个数组交给多个人去管理。

3、数组变量之间的赋值只是共享管理权限。

比如说  int[]a2 = a1;就是让a2一起管理这个数组

4、数组变量之间的比较只是判断是否管理同一个数组。

数组的拷贝以及对应元素的比较

数组的拷贝必须遍历整个数组。

public static void main(String[] args) { 
        Scanner in =new Scanner(System.in);
        int[] arr={1,2,3,4,5};
        int[] brr=new int[arr.length];
        for(int i=0;i");
        for(int i=0;i

数组各元素的比较同理,对应元素进行比较。

Scanner in =new Scanner(System.in);
        int[] arr={1,2,3,4,5};
        int[] brr=new int[arr.length];
        for(int i=0;i
数组的一些计算以及for-each循环 题1:计算某个数字输入了多少次。

如下代码计算1、2、3出现了多少次

注意:Java中数组在创建时,会默认初始化为0。

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        int[] nums=new int[4];
        System.out.println("请输入数字");
        int x=in.nextInt();
        while(x!=-1)//输入-1则结束计数
        {
            if(x>0&&x<4)
            {
                nums[x]++;
            }
            x=in.nextInt();
        }
        for(int i=1;i

题2:数组中的线性搜索(最笨的方法)
public static void main(String[] args) {     
        Scanner in =new Scanner(System.in);
        int[] arr={11,98,76,54,32};
        boolean flag =false;
        int i=0;
        int x=in.nextInt();
        for(i=0;i
For-Each循环

for-each循环是Java中的一种新的遍历数组的方式。比如在数组内,你只想要找到是否有某个元素,而不用知道下标,那么for-each循环是一个不错的选择。

缺点:无法通过for-eacch循环给数组进行赋值;无法找到数组对应元素的的下标。


下图中的for(int k : arr)是指:

从arr[0]开始,遍历arr数组,每次都将arr中的一个元素赋给k。

for-each格式:

for(<变量类型><变量名>:<数组>){

......

}

Scanner in =new Scanner(System.in);
        int[] arr={11,98,76,54,32};
        boolean flag =false;
        int i=0;
        int x=in.nextInt();
        for(int k:arr)
        {
            if(x==k)
            {
                flag=true;
                break;
            }
        }
题3:素数

方法1:遍历查找

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        int x=in.nextInt();
        boolean isP=true;
        int n=0;
        do{
            if( 1==x )
                isP = false;
            for(int i=2;i");
            isP=true;
            x=in.nextInt();
            }while(x!=0);
}

方法2:抛开偶数,只查奇数

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        boolean isP=true;
        System.out.println("请输入:>");
        int x = in.nextInt();
        while (x != 0)
        {

        if (x == 1 || x % 2 == 0 && x != 2)
            isP = false;

        else
        {
        for (int i = 3; i< x; i += 2)
        {
            if (0 == x % i)
            {
                isP = false;
                break;
            }
        }
        }
        if (isP) System.out.println(x + "是素数");
        else System.out.println(x + "不是素数");

        System.out.println("请继续输入:>");
        isP=true;
        x=in.nextInt();
        }
        System.out.println("程序结束。。。");
}

方法3:开根查找

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        boolean flag=true;
        System.out.println("请输入:>");
        int x=in.nextInt();
        while(x!=0) {
            flag = true;
            for (int j = 2; j<= Math.sqrt(x); j++) {
                if (x % j == 0) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                System.out.println(x+"是素数");
            } else {
                System.out.println(x+"不是素数");
            }
            System.out.println("请继续输入:>");
            flag=true;
            x=in.nextInt();
        }
}

方法4:素数表

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        int[]primes=new int[30];
        primes[0]=2;
        int cnt=1;
        OUT:
        for(int n=3;cnt<30;n++)
        {
            for(int i=0;i


字符类型

char表示单个字符,可以是字母'a',数字'1'、汉字'文' 。

Java使用Unicode表示字符,可以表示汉字在内的多种文字。

字母和数字在Unicode表中是按照顺序排列的,但是大小写是分开排列的,并不在一起。 48~57是0~9

65~90是A~Z

97~122是a~z

小写字母排在大写字母后面

//实现大小写转换
        Scanner in =new Scanner(System.in);
        char c1='A';
        char ret=(char)(c1+'a'-'A');
        System.out.println(ret);
  • 逃逸字符

逃逸字符:无法打印出来的控制字符或特殊字符,由反斜杠\开头

  • 包裹类型

包裹类型:

将一个基本数据类型的数据转换成对象的形式,使得它们可以像对象一样参与运算和传递。

既然有了基础类型,那么为什么要有包裹类型呢?

其实,包裹类型可以方便我们代码的书写,

如下图,在Character.中,有很多代码可以帮助我们简化程序的书写

包裹类型的一些使用:

public static void main(String[] args) {
        System.out.println(Character.toLowerCase('A'));//转换为小写
        System.out.println(Character.toUpperCase('b'));//转换为大写
        System.out.println(Integer.max(4,8));//输出较大的那个数
        System.out.println(Double.sum(1.2,3.8));//两个浮点数求和
}


Math类

Math类,用于提供一些数学操作。

注意:

三角函数中输入弧度制而不是角度制,例如:Math.sin(Math.PI/2)才是正确写法

方法作用
Math.abs取绝对值,返回类型与原类型相同
Math.round四舍五入,返回整型
Math.rint四舍五入(比较特殊)
Math.random随机数,范围是[0.0,1.0)返回类型double
Math.pow次方,pow(2,3)计算2的立方,输出8.0类型double
Math.ceil向上取整,double
Math.floor向下取整,double
Math.E自然对数e,e=2.718....
Math.PI圆周率π
Math.exp()exp(x)就是计算e的x次幂,指数函数
Math.sqrt开算术平方根,类型double
Math.log(x)数学中的对数函数lnx,返回double
Math.log10()数学中的lgx,返回double
Math.min返回最小值
Math.max返回大值
Math.toDegrees() 弧度转角度,Math.toDegrees(Math.PI/6); 输出 30.0,返回double
Math.toRadians()角度转弧度
Math.sin() 计算正弦值,返回double
Math.cos()计算余弦值,返回double
Math.tan()计算正切值,返回double
Math.asin()根据值计算角度,输出弧度,输入0.5,输出π/6
Math.acos()根据值计算角度,输出弧度
Math.atan()根据值计算角度,输出弧度

字符串 字符串的创建与连接

String str;
String(第一个字母S要大写)是一个类

String的变量是对象的管理者而非所有者,和数组类似

String str = new String("hello");

String str ="hello";

创建了一个String的对象,用"hello"初始化这个对象

创建了管理这个对象的变量str,让str去管理这个对象

用+可以连接两个字符串,如果+的一边是字符串,另一边不是呢?

答:它会将另一边表达为字符串然后连接

为什么左边是6?

因为运算是从左往右,第一个数字是1,为int,第二个数字是2,也为int,所以二者进行整型的加法,接着和3进行整型加法。

当碰到str时,被转换为字符串类型与hello连接,得到"6hello"

接着这整个字符串与下一位1进行运算,由于1是整型,要被转换为字符串类型,于是我们得到了"6hello1",后续同理。


字符串的输入

字符串的输入:

in.next();读入的是一个单词,单词结束标志是空格;

包括(空格space、缩进tab、换行符)

in.nextLine();读入的是一整行


字符串的比较

和数组相似,String的变量是对象的管理者而非所有者

如果用==进行比较,这只能判断二者是不是同一个东西。

如下图中,str1和str2的内容都hello,但是str2与"hello"并不相等。

如果要比较内容该怎么办呢?像遍历数组一样去遍历整个字符串吗?

并不,有一种更简单的方法,字符串对象中的.equals操作,如下

小结:

==判断的是二者是不是同一个东西。

.equals判断的是二者的内容是否相同。


对字符串操作

介绍:

字符串是对象,对它的所有操作都是通过“.”操作符来进行

格式:字符串.操作

这里的字符串可以是变量也可以是常量

  • 字符串比大小comparTo
//--------------字符串的比较compareTo---------------
public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        String str1="abc";
        String str2="abd";
        System.out.println(str1.compareTo(str2));//输出-1
        //这里是将str1与str2作比较,如果str1大,则返回1
        //若相等则返回0,如果str2大就返回-1
}
  • 获取字符串长度length()
//-------------获取字符串长度length()------------
public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        String str1="abcdefg";
        String str2=" ";//一个空格
        String str3="";
        String str4;
        System.out.println(str1.length());//输出7
        System.out.println(str2.length());//输出1
        System.out.println(str3.length());//输出0
        System.out.println(str4.length());//error
        //因为str4没有管理任何String的对象
}
  • 访问字符串里的单个字符

str.charAt(index);

返回在index位置上的单个字符

index的范围是0~length()-1

字符串中第一个字符的index是0,和数组类似

注意:不能用for-each遍历字符串

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        String str = "12ab啦啦";
        for(int i=0;i

  • 得到字符串的子串

s.substring(n)

得到从n号位置到末尾的全部内容

s.substring(a,b)

得到从a号到b号位置之前(不包括b号位置)的内容

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        String str="012345哈哈哈";
        System.out.println(str.substring(5));
        System.out.println(str.substring(0,6));
}


  • 寻找某个字符

str.indexOf('char') 找到char字符所在的位置,找不到就返回-1

str.indexOf('char' , n) 从第n号位置开始找char字符,返回首次找到的char字符的下标

str.indexOf('str1') 找到字符串str1所在的位置(该字符串首字符的位置)

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        String str ="hello world";
        System.out.println(str.indexOf('w'));//6
        System.out.println(str.indexOf('l'));//2
        //如果我要找第二个l怎么办?
        int loc = str.indexOf('l');
        System.out.println(str.indexOf('l',loc));//依旧是2
        System.out.println(str.indexOf('l',loc+1));//此时才是3
        System.out.println(str.indexOf('l',loc+2));//此时是9
}

诸如str.lastIndexOf()的操作就是从后往前找。


  • 其他String操作
str.startsWith()是否以某个字符串开头,返回true or false
str.endsWith()是否以某个字符串结尾,返回tre or false
str.trim() 删掉字符串两端的空格
str.replace(s1,s2)将字符串中的s1全部替换成s2
str.toLowerCase()将所有字符变成小写
str.toUpperCase()将所有字符变成大写

代码演示:>

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        String str="Hello Nyx";
        String str2="  Hello Nyx  ";
        System.out.println(str.startsWith("Hello"));//是否以某个字符串开头
        System.out.println(str.startsWith("abc"));
        System.out.println(str.endsWith("nyx"));//是否以某个字符串结尾
        System.out.println(str2.trim());//删掉字符串两端的空格
        System.out.println(str.replace('l','a'));
        System.out.println(str.toLowerCase());//所有字符变成小写
        System.out.println(str.toUpperCase());//所有字符变成大写
}


注意:

在Java中,所有的字符串都是不可变的

对字符串的操作结果都是制造出一个新的字符串再将该字符串返回

不会改变原字符串!!!!!

示例如下:>


一点小尾巴:

在C语言中,我们的switch-case中都是用整型表示

但是在Java中在switch-case中也可以使用字符串 
Java中的"new"运算符为每个对象分配内存空间,而C语言中通过malloc()和free()分别实现对于的内存的分配和运用,这一点还是很方便的。

Over.

你是否还在寻找稳定的海外服务器提供商?创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源,准确流量调度确保服务器高可用性,企业级服务器适合批量采购,新人活动首月15元起,快前往官网查看详情吧


文章名称:Java入门知识以及细节(1.3w字笔记)-创新互联
标题URL:http://chengdu.cdxwcx.cn/article/dheied.html