java的变量

是一块特定的内存空间,由一个或多个字节组成的。
把变量比喻成房间就非常容易理解了,一个房间(变量)需要门牌号(变量名),这样才会找到并使用(赋值)。

数据类型

java的数据类型有八个,如图:

其中的String是常用类型,并不属于基本类型,一定要记得!java还有一个并不常见的类型叫:void ,这个不管是在哪个语言,中文意思都是一样的,无返回、空值。
java常用的基本类型有四个:int long double
boolean这几个。
声明变量名不能使用关键字,这里要注意,也不能使用数字做开头的变量名,更不能起重复的变量名,重复的变量名有些编译器不报错,但是打印结果的时候就会不对,并且自己也不知道错在哪个地方。下面这些都是不正确的:

正确的命名可以使用首字母、下划线、符号 + 任意的数字、字母、或者是下划线和符号,不过最好还是起有意义的名字,这样一看就知道这个变量名是用来干什么的。


运算符

java的运算符和其他语言差不多,也是 + – * / % ++ — 这类的
而且运算顺序也是没有变化,如:

public class Name{
    public static void main(String[] args){
        int num = 5;
        int num2 = 6;
        int num3;
        num3 = (num + num2++) * 2 / 1 % 3;
        System.out.print(num3);
    }
}

猜猜这段代码最后输出的结果是多少?


boolean类型适用于判断语句,因为它的返回值只有两个,true false,真和假,看例子:

public class Name{
    public static void main(String[] args){
        int num = 80;
        int num2 = 70;
        boolean isBig;   //定义boolean变量isBig,存储比较结果
        isBig = num < num2;    //将比较的结果存储到isBig里
        System.out.print("这两个值的比较结果是: "+ isBig);  //输出比较结果

    }
}

可以试运行这段代码看看会输出什么样的结果.

java是什么

简单来说JAVA是一门面向对象的编程语言,功能强大,平台独立、可移植性、安全性等特点。


java的发展

1995年由Sun Microsystem公司推出,起源于Sun公司的绿色项目(Green Project)1995年正式将Oka改名为java,全球互联网的兴起给了java新的生命与舞台。

java能做什么

java能开发很多应用软件,桌面应用软件如:银行软件、商城软件等
开发面向internet的应用软件:网上数码商城、阿里巴巴等


java三大平台

JAVA SE:是学习及开发java其他平台应用的基础,它包括:JVM、JRE、JDK和java
JAVA EE:以SE为基础的深入学习,定义了另一系列的服务、API、协议等;适用于开发分布式、以WEB为基础的应用程序。
注意:java EE在java 6版本以前又叫做J2EE,到7以后才改为JAVA EE的
JAVA ME:移动端的语言现在应用的非常少

JAVA SE分成四个部分

JVM:将java编译好的文件翻译成对应的机器语言,然后机器再将运行后的结果显示在电脑屏幕上
JRE:包含用于java的运行环境,电脑下载后用于配置环境的
JDK:包含用于java开发的工具
java语言:定义Java开发的语法规则(学习语法规则是重点)

Java的运行

java有一个特点就是能用记事本写程序然后直接在控制台上运行,但这样的只能进行简单的程序,一旦代码多了不仅难看还不容易发现错误,所以尽可能使用编译器来书写java。
java的程序结构和C语言的结构不一样,单词量多,格式不一样,输出也不一样,如:

public class NAME{
    public static void main(String[] args){
        System.out.print("Hello word");
    }
}
int main()
    {
    printf("Hello word!");
}

如上面两个代码所示,java比C多了很多单词量,看起来也比较复杂,而C相对来说就简单很多,几句简单的代码就能完成一个输出了,但是也不能仅凭几行代码就忽略了java的优点稳定可移植,并且能独立运行,还能开发很多软件,相比之下C虽然不行,可是很多语言都是基于C的基础上开发出来的,所以C算的上是编程界的大佬语言。
在书写java的时候要注意缩进、字母的大小写,符号等问题,还有不管写什么语言一定要记得注释,否则到头来自己都忘了之前的变量是干什么的,这个程序又是干什么的了。

数组的增删改查也是对于初学者来说对数组最好的理解应用了,熟练掌握它们的运用能帮助我们更好的处理数组的问题。并且能加深我们理解数组和循环的关系。
在理解这些之前,我们先要明白数组的结构和基本要素,我们先看一个例子:

int nums[5] = {2,3,5,7,11};

在这里,我们定义了一个int型的数组,这个数组叫nums,5代表这个数组中最多可以存放5个元素。大括号中是这个数组的元素,它们的数据类型要和定义数据类型相匹配。每个元素在数组中的位置可以通过元素下标来进行访问,元素下标命名规则就是数组元素中从左往右,从0开始的顺序数字。

看过解析后我们简单归纳一下数组结构和基本要素:

1.标识符(数组名称nums)
2.数组元素(大括号里存放的数据)
3.元素下标(数据在数组中的位置)
4.元素类型(int)

简单了解数组之后,我们通过一些例子来理解数组的增删改查

1. 数组的增加功能

例1:在一个数组a中插入一个用户输入的数字(假设这个数组是int型数组)

int main()
{
    int count = 5;                      //定义数组长度变量,增加和删除会改变数组长度。
    int num;                            //需要插入的数字和用来交换数字的临时变量
    int a[] = {2,8,11,1,5};             //定义一个数组
    printf("请输入您需要增加的数字:");
    scanf("%d",&num);
    //插入数字
    a[count] = num;                     //把输入的数字赋给数组,再将数组总长度+1
    count++;
    //打印结果
    printf("插入数字后的结果是:\n");
    for(int i = 0; i < count; i++)
    {
        printf("%d\t",a[i]);
    }
    return 0;
}

打印结果是:

[数组的增加打印结果](https://tieba.baidu.com/p/5706406675 "数组的增加打印结果")

数组的增加就是把它的长度扩充一位,然后在那个多出来的位置上赋上我们要插入的数据。

2.数组的删除功能

首先我们要理解删除的本质,它不是真正删除数组中的某个数据,而是先找到这个值之后,把它后边的值依次赋给前一个值,最后再把数组长度扣掉一位来实现删除的目的。

如在数组{2,8,11,1,5}中我们想删除8,那么我们只需把8之后的值依次赋给前一个值,即{2,11,1,5,5},最后将总长度减1,得到{2,11,1,5}从而实现删除。

例2:在例1定义的数组中,实现删除它其中一个数字的功能

int main()
{
    int count = 5;                  //定义一个变量来表示数组元素的个数
    int a[] = {2,8,11,1,5};
    int deleteNum;                  //定义一个用户想删除的值的变量
    int deleteIndex = -1;           //定义一个需要删除的战力值的下标,并给它赋一个不可能实现的初值。方便判断(理解这里)
    //输入想要删除的数字
    printf("请输入您想删除的战力值:");
    scanf("%d",&deleteNum);
    //开始查找需要删除的数字
    for(int i = 0; i < count; i++)  //循环次数和数组元素个数相同
    {
        if(deleteNum == a[i])       //输入的战力被找到
        {
            deleteIndex = i;        //记录下找到的值的下标
            break;                  //找到后直接跳出循环,提升效率
        }
    }
    //根据判断它是否找到,执行后续操作
    if(deleteIndex == -1)           //没有找到的情况
    {
        printf("没有找到您想删除的战力值。\n");
    }
    else                            //找到的情况
    {
        for(int i = deleteIndex; i < count - 1; i++)        //找到之后,数组的元素个数要比原来少一个,所以是i < count - 1
        {
            a[i] = a[i + 1];        //把要删除的后一个值依次赋给前一个值
        }
        //删除完毕后,数组的总长度要减1
        count--;
    }
    //打印结果
    printf("删除后的结果为:\n");
    for(int i = 0; i < count; i++)
    {
        printf("%d\t",a[i]);
    }
    return 0;
}

打印结果是:

[数组的删除打印结果](https://tieba.baidu.com/p/5706406675 "数组的删除打印结果")

定义元素下标并给初值就是为了方便我们进行判断没有找到的情况。因为下标不可能是负数。

3.数组的修改功能

想要修改数组中的某个元素,我们需要先判断用户输入的数字是不是数组里的元素,如果是我们需要找到它所在的位置(下标),然后直接给它赋一个修改后的新值即可。

例3:在例1的数组中将11改成45并打印结果。

int main()
{
    int a[5] = {2,8,11,1,5};        //定义数组
    int findNum;                    //定义需要查找的数字的变量
    int temp;                       //修改数字的临时变量
    int findIndex = -1;             //要查找的数字的元素下标并服初值
    //开始输入
    printf("请输入您要查找的数字:");
    scanf("%d",&findNum);
    //开始查找
    for(int i = 0; i < 5; i++)
    {
        if(findNum == a[i])
        {
            findIndex = i;         //如果找到直接赋值并跳出循环
            break;
        }
    }
    //判断是否找到的情况
    if(findIndex == -1)
    {
        printf("没有查找到该数字!\n");
    }
    else
    {
        printf("请输入修改后的数字:");      //输入的数字直接赋值给他
        scanf("%d",&temp);
        a[findIndex] = temp;
    }
    //打印结果
    printf("修改后的数组是:\n");
    for(int i = 0; i < 5; i++)
    {
        printf("%d\t",a[i]);
    }
    return 0;
}

打印结果是:
[数组增加打印](https://tieba.baidu.com/p/5706406675 "数组增加打印")

不难看出程序的执行过程,我们先找到需要删除的数组元素直接赋值,就达到了修改的目的。

4.数组元素的查询功能

从数组的增,删,改中我们不难发现,想实现这三个功能数组必须先查询。所以查询是实现增删改的基础。只要了解了数组的增删改,查询也就不难实现了。下面我们用一个简单的小例子来理解它。

例4.还是例1的数组,要求用户从键盘录入一个数,程序判断这个数是不是数组中的元素

int main()
{
    int a[5] = {2,8,11,1,5};            //定义数组
    int findNum,index;                  //查找的数字变量和下标
    //开始查找
    printf("请输入数字:");
    scanf("%d",&findNum);
    int i;
    for(i = 0; i < 5; i++)
    {
        if(findNum == a[i])             //如果输入的数字恒等于数组中某个i的值,即输入的数字和数组中i的元素是相同的
        {
            index = i;                  //记录这个数字所在的下标
            printf("您输入的数字在数组中!它所在的下标是%d。\n",index);
            break;                      //数组的查询是挨个比较,所以找到需要用break跳出循环
        }
    }
    if(i == 5)                          //元素下标恒等于5代表输入的数字已经和数组的元素全部比较过一遍都不匹配。
    {
        printf("没有您想找的数字!\n");
    }
    return 0;
}

如果输入的数字在数组中,打印结果为:
[输入的数字被找到](https://tieba.baidu.com/p/5706406675 "输入的数字被找到")

如果输入的数字不在数组中,打印结果为:
[输入的数字不在数组中](https://tieba.baidu.com/p/5706406675 "输入的数字不在数组中")

最后思考一个问题:为什么我们找到数字之后需要用break直接跳出循环呢?

  • 因为我们输入的数字是和数组里的元素挨个进行比较的,如果不加break语句,输出结果里不管有没有找到都会打印出来,如下所示:

[不加break中断](https://tieba.baidu.com/p/5706406675 "不加break中断")

找到数字之后它还会和其他的数字进行比较,并得出没有找到的结论。所以加break不仅可以节省资源和时间,还能避免程序犯一些逻辑方面的错误。

总结:

  • 数组的增删改查是我们学习代码的基本,它将数组和循环灵活的结合在一起,只要搞清楚它们的原理,就能更好的帮助我们学习更复杂的代码。希望这篇笔记能帮助同学们更好的理解数组和循环的使用实现数组的增删改查。

            插入数组

int len = 6; /**定义的数组长度**/
int nums[7]={66,55,44,33,22,11};
/**nums[len]会报错(C语言在定义的[]里面只能是常量) 因为要插入所以要多定义一个所以定义7,虽然里面只有6个元素**/
for(int i = 0; i &lt; len; i++){    
/**刚好打印6个元素**/
    printf(&quot;%d\t&quot;,nums[i]);
}
int insertNum; /**定义要插入的数字**/
int insertIndex = -1; /**定义要插入的数字下标**/
printf(&quot;\n输入要插入的数字:&quot;);
scanf(&quot;%d&quot;,&amp;insertNum);
for(int i = 0; i  nums[i]){ /**当插入的数字大于数组中的某一个数时,记录下标**/
        insertIndex = i; /**比谁小记录谁的下标**/
        break;           /**直接跳出循环,因为是降序排列所以插入的数字可能会大于后面的好几个数字
                            所以找到第一个大于的就直接break;**/
    }}
if(insertIndex == -1){ /**插入的数字比数组的都小**/
    nums[len] = insertNum;  /**直接将插入的数字赋值给数组最后一位的后面即最小的nums[len]**/
}
else{
    for(int i = len - 1; i &gt;= insertIndex; i--){ /**len - 1 因为插入是前面一个往后面移(从最后面开始移动即 i = 5-&gt;6开始) 数组元素有6个所以下标是0-5 len长度是6 所以len - 1 而 i &gt;= insertIndex的意思是只要大于我插入数字的下标就往后移动直到等于我插入数字的下标**/
        printf("i = %d\t",i);
        nums[i + 1] = nums[i];  /**将i=5 -&gt; i=6  i=4 -&gt; i=5 移动到i=insertIndex为止**/
    } nums[insertIndex] = insertNum; /**当移动到i = insertIndex的时候 就将输入的insertNum  赋值给nums[insertIndex]就完成了插入**/
}printf("\n");
for(int i = 0; i &lt; len + 1; i++){ /**打印插入后的数据 len+1:总长度因为加了1**/
    printf(&quot;%d\t&quot;,nums[i]);
}

** 数组 **

    数组:数组是一串连续的内存空间,且是由相同数据类型的变量组成
    数组的基本要素。
    1、标识符   数组的名称
    2、数组元素  数组的内容
    3、元素下标  数组的索引(查找数组中的内容需要用到索引)
    4、元素类型  数组的数据类型(与变量的数据类型是一样的)
    例:
    int array[8];   //定义一个整形的数组名为array,里面还有8个int型的数据

** 数组的动态录入 **

    示例:
    #inlcude <stdio.h>
    #define N 5             //宏定义
    int main()
    {
        int num[N];         //定义一个整形数组用来保存动态录入的值
        int i;      //循环变量
        for(i = 0; i < N; i++){
            printf("请输入数组中第%d个元素的值:",i + 1);
            scanf("%d",&num[i]);        //循环赋值
        }
        printf("打印录入的值:");
        for(i = 0; i < N; i++){
            printf("%d\t",num[i]);
        }
        return 0;
    }

** 数组的增删改查 **

数组中元素的查找
    个人理解:数组的增删改的前提在于查找
    示例:
    #include <stdio.h>
    #define N 5
    int main()
    {
        int num[N] = {33,22,11,55,66};  //定义一个整形变量,并初始化它的值
        int serchNum;       //用户想要查找的数据
        int serchIndex = -1;    //要查找的元素下标,给一个在数组中不可能出现的值
        printf("请输入您要查找的数据:");
        scanf("%d",&serchNum);      //输入要查找的数据
        for(int i = 0; i < N; i++){ //遍历数组中的内容
            if(serchNum == num[i]){ //如果输入的数据在数组中查找到了
                serchIndex = i;     //将当前数组的下标赋值给serchIndex
                break;      //找到了立即退出,节省资源
            }
        }
        if(serchIndex == -1)        //如果要查找的数组元素下标还是等于初值
        {
            printf("数组中没有要查找的数据,查找失败\n");
        }
        else    //找到了
        {
            printf("找到了!该数据在数组中的下标为:%d\n",serchIndex);
        }
        return 0;
    }
数组中元素的删除
    数组元素的删除前提在于能够在数组中查找到要删除的数据
    删除逻辑:当查找到要删除的元素后,记录下标。然后从要查找的元素下标开始,后面一个覆盖前面一个,然后数组总长度 - 1,最后打印删除后的数组
    #include <stdio.h>
    #define N 5
    int main()
    {
        int num[N] = {33,22,11,55,66};  //定义一个整形变量,并初始化它的值
        int serchNum;       //用户想要查找的数据
        int serchIndex = -1;    //要查找的元素下标,给一个在数组中不可能出现的值
        printf("请输入您要查找的数据:");
        scanf("%d",&serchNum);      //输入要查找的数据
        for(int i = 0; i < N; i++){ //遍历数组中的内容
            if(serchNum == num[i]){ //如果输入的数据在数组中查找到了
                serchIndex = i;     //将当前数组的下标赋值给serchIndex
                break;      //找到了立即退出,节省资源
            }
        }
        if(serchIndex == -1)        //如果要查找的数组元素下标还是等于初值
        {
            printf("数组中没有要查找的数据,查找失败\n");
        }
        else    //找到了,就执行删除算法
        {
            for(int i = serchIndex; i < N; i++){    //从要删除的元素下标开始
                num[i] = num[i + 1];    //后面一个覆盖前面一个
            }
            N--;    //数组总长度 - 1
            printf("打印删除后的数组:");
            for(int i = 0; i < N; i++){ //循环打印删除元素后的数组
                printf("%d\t",num[i]);
            }
        }
        return 0;
    }
数组中元素的插入
    向数组中插入元素有三种情况
    1、数组中还有空间(这个是前提条件)
    2、不排序(直接把要插入的元素赋值给以当前元素总量为下标的数组元素)
如:int num[5];   //定义一个整形数组名为num
假设此时数组中实际只有4个元素,也就是说当前数组总量为四int num[count];//count = 4
此时可以插入元素。可以直接赋值,如:num[count] = 要插入的元素;然后数组总长度 + 1,最后打印
    3、需要排序(这种如果是已经排序好了的,直接赋值给最后一个元素的话,最后还需要排序,比较麻烦,也浪费时间)这时可以使用查找算法,然后在从当前数组的最后一个元素开始,从前往后赋值,直到查找到的下标结束,然后将要插入的元素直接赋值给查找到的元素,然后打印
    //以下为实例


    #include <stdio.h>
    #define N 6
    int main()
    {
        int num[N] = {66,55,44,33,22};  //定义一个整形变量,并初始化它的值
        int count = 5;      //当前数组中的元素个数
        int serchNum;       //用户想要查找的数据
        int serchIndex = -1;    //要查找的元素下标,给一个在数组中不可能出现的值
        printf("请输入您要插入的数据:");
        scanf("%d",&serchNum);      //输入要查找的数据
        for(int i = 0; i < count; i++){ //遍历数组中的内容
            if(serchNum > num[i]){  //如果输入的数据在数组中查找到了
                serchIndex = i;     //将当前数组的下标赋值给serchIndex
                break;      //找到了立即退出,节省资源
            }
        }
        if(serchIndex == -1)        //如果要查找的数组元素下标还是等于初值
        {
    //这种情况表明插入的元素,比数组中所有元素都小或答,可以直接赋值给最后一个位置
            num[count] = serchNum;  //直接赋值
            count++;            //数组总长度 + 1
        }
        else    //找到了
        {
            for(int i = count; i > serchIndex; i--){//从最后一个位置开始依次赋值
                num[i + 1] = num[i];
            }
            num[serchIndex] = serchNum; //将要插入的元素赋值给查找到的下标
            count++;        //插入后数组总长度 + 1
        }
        printf("打印插入后的数组:");
        for(int i = 0; i < count; i++)
        {
            printf("%d\t",num[i]);
        }
        return 0;
    }
数组中元素的修改
    数组元素的修改逻辑:首先要查找到想要修改的元素下标,如果没有找到就提示找不到要修改的元素,修改无法进行,如果找到了,就将要修改的元素直接赋值就行。但是要注意数据类型要相匹配
    示例:
    #include <stdio.h>
    #define N 5
    int main()
    {
        int num[N] = {33,22,11,55,66};  //定义一个整形变量,并初始化它的值
        int serchNum;       //用户想要查找的数据
        int temp;           //定义一个临时变量用来储存要修改的数据
        int serchIndex = -1;    //要查找的元素下标,给一个在数组中不可能出现的值
        printf("请输入您要查找的数据:");
        scanf("%d",&serchNum);      //输入要查找的数据
        for(int i = 0; i < N; i++){ //遍历数组中的内容
            if(serchNum == num[i]){ //如果输入的数据在数组中查找到了
                serchIndex = i;     //将当前数组的下标赋值给serchIndex
                break;      //找到了立即退出,节省资源
            }
        }
        if(serchIndex == -1)        //如果要查找的数组元素下标还是等于初值
        {
            printf("数组中没有要查找的数据,查找失败\n");
        }
        else    //找到了
        {
            printf("请输入您要修改的内容:");
            scanf("%d",&temp);
            num[serchIndex] = temp; //直接赋值
        }
        printf("打印修改后的数组:");
        for(int i = 0; i < N; i++){
            printf("%d\t",num[i]);
        }
        return 0;
    }
数组的排序
    冒泡排序(这就是一个公式,死记灵活用就行)
    示例:
    #include <stdio.h>
    #define N 5     //宏定义
    int main()
    {
        int num[N] = {32,55,66,11,44};  //定义一个整数数组并初始化
        int i,j,temp;       //定义循环变量i,j,temp
        for(i = 0; i < N - 1; i++){//从第一个元素开始,依次与后面的比较
            for(j = 0; j < N - i - 1; j++){
                if(num[j] > num[j + 1]) //升序
                {
                    temp = num[j];      //交换变量
                    num[j] = num[j + 1];
                    num[j + 1] = temp;
                }
            }
        }
        printf("打印排序后的数组:");
        for(i = 0; i < N; i++){
            printf("%d\t",num[i]);
        }
        return 0;
    }

数组

数组是一块连续的内存空间
int num[5] = {12, 15, 17, 19, 22};
这样就是定义了一个整型有20个字节的名为num的空间。
常和循环连用,是一对好基友,如:
int i;
for(i = 0; i < 5; i++)
{
printf("%d ", num[i]);
}
这是使用循环来连续输出数组的例子,小于5是因为数组的最大空间就是5,printf函数里的num[i]意思是打印num里的第i个元素,这有程序就会连续输出数组了,直到i 的值为5就停止打印。
5也可以使用常量来代替,如:
#define N 5
for(i = 0; i < N; i++) ……
需要注意的是 常量的字母必须是大写的,后面的数字就是你自定义的数字。

它的基本操作:
1、动态录入
#define N 5
int num[5]; //记录用户输入的数组
int i; //循环变量
fori(i = 0; i < N; i++)
{
printf("请输入数字: ");
scanf("%d", &num[i]); //使用sanf函数时,不要忘记&符号
}
2、数组的排序:需要背诵固定代码(冒泡排序)

#define N 5
    int nums[N] = {66, 25, 12, 9, 11};
    int i, j;          //循环变量
    int temp;          //临时变量
//需要用到嵌套循环
//外层循环控制轮数
for(i = 0; i < N - 1; i++)  //N - 1代表的是(数组长度 - 1)轮
    {
      //内层循环控制的是比较的次数
    for(j = 0; j < N - i - 1; j++)  //N - i- 1意思是数组每次比较的次数比上轮都少一次
        {
        //如果当前值小于后面一个值,就交换
        if(nums[j] < nums[j + 1]) 
            {
            temp = nums[j];
            nums[j] = nums[j + 1];
            nums[j + 1] = temp;
        }
    }
}
printf("排序后的: ");
for(i = 0; i < N; i++)
    {
    printf("%d ", nums[i]);
}

3、数组元素的插入(插入后仍然有序)

#define N 6     //定义了一个有6个空间的数组
    int nums[N] = {10, 17, 22, 30, 36};    //只使用了5个空间
   int len = 5;          //当前的总长度为5
   int i;               //循环变量
   int  inserNum;       //记录插入的数字
   int inserIndex= -1  //记录插入数字的下标
  printf("请输入要插入的数字: ");
  scanf("%d", &inserNum);
for(i = 0; i < len; i++)  //遍历数组是否有这个数字
    {
    if(inserNum < nums[i])  //如果输入的数字比数组中的每一位小
        {
        inserIndex = i;     //记录下标
        break;             //跳出循环
    }
}
if(inserIndex == -1)  //如果inserIndex 还是初值,就表示没找到
    {
    nums[len] = inserNum;        //把插入的数字直接放到数组最后一位
    len++;                       //一定要记得长度+1,否则空间不足会报错
}
else   //找到后
    {
    for(i = len - 1; i > inserIndex; i--) //从最后一位开始赋值
        {
        nums[i + 1] = nums[i];
    }
}
nums[inserIndex] = inserNum;             //将插入的数字赋值给查找的下标
len++;                                  //最后总长度一定记得+1
//最后再次打印,检查是否插入成功
printf("插入数字后的数组为: ");
for(i = 0; i < len; i++)
    {
    printf("%d ", nums[i]);
}

4、数组元素的删除

int nums[5] = {77, 33, 25, 10, 62};
int len = 5;            //数组的总长度
int delNum;             //要删除的数字
int delIndex = -1;      //记录要删除的下标
int i;                 //循环变量

printf("请输入要删除的数字: ");
scanf("%d", &delNum);
for(i = 0; i < len; i++)
{
    if(delNum == nums[i])  //如果要删除的数字等于数组中的某位
    {
        delIndex = i;        //就记录下标
        break;              //跳出循环
    }
}
if(delIndex == -1)   //如果delIndex返回的是负数
    {
    printf("没有找到要删除的数字.\n");
}
//删除的核心逻辑
for(i = delIndex; i < len - 1; i++) //把找到删除数字的下标赋给 i
    {
    nums[i] = nums[i + 1];          //后面一个元素覆盖前面一个元素
}
len--;                  //最后总长度一定要减一
printf("删除后的数组为: ");
for(i = 0; i < len; i++)
{
    printf("%d ", nums[i]);
}

总结

不管是增加还是删除元素,最后都要记得修改总长度的值,否则将不知道程序会给出什么样的结果.

#变量和数据类型

1.变量: 变量被用来存储处理的数据,是计算机中的一块内存

2.基本数据类型:

整数类型:byte , short , int , long
浮点类型:float, double
字符型:  char
布尔型:  boolean

3.数据类型的大小:

byte      1 字节          -128——127 
char      2 字节        -128——127  整个Unicode字符集 
short     2 字节         -32,768 —— 32,767 
int       4 字节         -2,147,483,648 ——2,147,483,647(超过20亿) 
long      8 字节  -9,223,372,036,854,775,808——9,223,372,036854,775,807 
float     4 字节        
double    8 字节         
byte&lt;short&lt;int&lt;long&lt;float&lt;double  按照大小排序(1字节为8位)
boolean    1 位             true或者false 

4.特殊的数据类型:String
String 类型不是基本数据类型,它其实是char的数组是一种特殊的类型,它的大小不定

第一周笔记

OS ⟹ Operation System
⟹ Operation :操作 System:系统
DOS⟹ D:Disk ⟹ 磁盘

把数据内存保存到外存:数据分化

bit : 位
byte : 字节
八位一字节

2进制转8进制和16进制用8421法。

反码: 正数的反码是其本身,负数的反码是在其原码的基础上,符号位不变,其余各位取反。
补码:正数的补码是其本身,负数是在原码的基础上,符号位不变,其余各位取反,最后+1,即,在反码的基础上+1。

操作系统的主要功能:
1. 用户界面
2. 资源管理
3. 文件管理
4. 安全性

IP地址:32位,由4个8位2进制组成,使用点分十进制表示。
网络ID:标识设备所在网络
主机ID:标识特定设备

数据类型:规定变量所占内存空间的大小。
变量就是1个空间。

scanf ⟹ san format ⟹ scanf : 扫描 format : 格式 ⟹ 按照格式扫描
printf ⟹ print format⟹ print : 打印 ⟹ 按照格式打印

float:单精度浮点型 6-7位有效数字
double:双精度浮点型 15-16位有效数字

a-b之间的随机数:rand()%(b-a+1)+a

第二周笔记

强制类型转化的前提:大类型转小类型。
自动类型转换:小类型赋给大类型。

按位异或:∧同假异真

sizeof只计算空间值,里面的运算全部忽略。

循环变量三要素:
1.循环变量需要初值。
2.循环变量需要判断。
3.循环变量需要更新。

初期使用计算机处理问题的四个步骤:
1.定义变量。
2.提示用户输入及接收用户的输入。
3.根据用户的输入进行判断及计算过程。
4.打印计算结果。

sum += i : sum = sum + i.

短路运算:
&&:左侧为假,就短路。
||:左侧为真,就短路。

num % 10 : 取个位
num / 10 : 去个位

数组是一个变量,由数据类型相同的同一组元素组成。

循环三要素:
循环变量的初值
循环变量的判断
循环变量的更新

while循环

while(循环条件)
{
循环操作语句
}
**while循环的特点是先判断,在执行**

do while循环

do
{
循环操作
}
while(循环条件);

do while循环的特点是先执行,再判断
先执行一边循环操作,符合条件,循环就继续运行,否则跳出循环

**while循环和do-while循环的区别 **

1.执行顺序不同 
2.初始情况不满足循环条件时:
while循环一次都不会执行 
do-while循环不管任何情况都至少执行一次

srand(time(NULL)) 是以时间为种子取随机数 1970-1-1到现在为止的毫秒数

短路运算
&& 左侧为假 就短路
|| 左侧为真 就短路

小结:

循环结构可以理解为加强版的if
循环三要素在初期是理解循环原理的拐杖
while循环先判断在执行
do while循环先执行后判断
注意死循环

关于计算机

计算机的概念

 计算机是执行程序指令的电子设备。

四种基本功能

 输入、输出、存储和处理

计算机的组成

 计算机系统包括硬件系统和软件系统。
 硬件系统包括主机和外围设备;软件系统包括系统软件和应用软件。

CPU的工作原理

 控制单元从存储器中提取输入数据和指令集,将指令进行解码,然后发送到算术逻辑单元(ALU)进行执行并储存输出结果。

数制系统及原码、补码、反码

十进制转其他进制

 取余法

其他进制转10进制

 按权展开法

原码反码补码转换

 正数和负数的反码、补码都是自身。
 负数的反码是在其原码的基础上,符号位不变,其余各位取反。
 负数的补码是在其原码的基础上,符号位不变,其余各位取反,最后+1。即在反码的基础上+1。

了解操作系统

操作系统简介

 操作系统是管理计算机硬件资源,控制其他程序运行并为用户提供交互操作界面的系统软件的集合。
 操作系统是计算机系统的关键组成部分,负责管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本任务。
 操作系统的主要功能:用户界面、资源管理、文件管理、安全性。

操作系统分类

以用户数量分:
  单用户操作系统(一台计算机在同一时间只能由一个用户使用,一个用户独享系统的全部硬件和软件资源)和多用户操作系统(在同一时间允许多个用户同时使用计算机)。
以同时运行应用程序(任务)的数量分:
  单任务操作系统和多任务操作系统。
以用户界面分:
  基于字符界面和基于图形界面(GUI)。

常用快捷键

 Ctrl + c/v/x : 复制/粘贴/剪切
 Ctrl + z :撤销
 Ctrl + a :全选
 Ctrl + s/n/o :保存/新建/打开
 Ctrl + f :查找
 Ctrl + Home/End :光标移到文件头/文件尾
 Ctrl + B/U/I :粗体/下划线/斜体

计算机网络

概念

 一组相互连接的计算机使用物理线路进行连接。

网络的分类

 局域网(LAN)、城域网(MAN)和广域网(WAN)。

网络通讯基础概念

 TCP/IP:传输控制/网际协议
 IP地址:唯一标识网络上的计算机
IP地址 = 网络ID + 主机ID
  网络ID:标识设备所在网段
  主机ID:标识特定设备

IP地址的分类

IP地址根据网络ID的不同分为5种类型

类别 ID ID ID ID
A类

1~126 0 0 0
B类

128~191 0~255 0~255 0~255
C类

192~223

0~255

0~255 0~255
D类 192~223 0~255 0~255 0~255
E类 240~255 0~255 0~255 0~255