Java-P2:数组，冒泡，快排，类练习

最新推荐文章于 2023-03-02 16:49:38 发布
最新推荐文章于 2023-03-02 16:49:38 发布
阅读量538 收藏 1
点赞数
分类专栏： 算法与数据结构 文章标签： 数据结构 数组 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flower_CSDN/article/details/78187905
版权

1.考试成绩已经保存在数组scores中，依次为 89,23,64,91,119,52,73,-23
要求根据通过自定义方法来找出其中前三名，将数组成绩作为参数传入
要求判断成绩的有效性(0-100),如果成绩无效，则忽略此成绩
写的复杂了，哈哈！

 /**
 * 
 */
package arrayOperation;
/**
 * @author 花花
 *1.从键盘输入n名学生成绩
  要求根据通过自定义方法来找出其中前三名，将数组成绩作为参数传入
  要求判断成绩的有效性(0-100),如果成绩无效，则忽略此成绩.
 */
import java.util.*;
public class ScoreArray 
{
    static int validN;//合法数据个数
    int[] score;
    //从键盘输入n名学生成绩
    ScoreArray(int n)
    {
        System.out.println("请输入学生成绩:");
        Scanner s=new Scanner(System.in);
        score=new int[n];
        for(int i=0;i<n;i++)
        {
            score[i]=s.nextInt();           
        }
        //s.close();
    }
    //判断成绩的有效性(0-100),如果成绩无效，则忽略此成绩.
    public static void IsValid(int[] a)
    {   
        int times=0;
        for(int i=0;i<a.length-1;i++)
        {
            if(a[i]<0||a[i]>100)
            {
                for(int j=i;j<a.length;j++)
                {
                    a[j]=a[j+1];
                    times++;//a.length--;不能对length赋值
                }   
            }
            validN=a.length-times;
        }       
    }//方法IsValid结束
    //找出其中前三名，将数组成绩作为参数传入
    public static void sortScore(int[] a,int n)
    {
        IsValid(a);
        for(int i=0;i<n;i++)
        {
            for(int j=i+1;j<validN;j++)
            {
                if(a[i]<a[j])
                {
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }
        }
        for(int i=0;i<n;i++)
        {
            System.out.print(a[i]+"  ");
        }
    }//方法sortScore结束
    public static void main(String[] args)
    {
        System.out.println("请输入学生人数:");
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        //in.close();
        ScoreArray sa=new ScoreArray(n);     
        System.out.println("前三名的成绩为：");
        sortScore(sa.score,3);      
    }//方法main结束
}//类ScoreArray结束

运行结果：
这里写图片描述
2. 用数组来实现， 定义并初始化一个（1–100）保存100个数的数组，从第一个元素开始，依次数(1,2,3 循环往复),每次数到到3的元素淘汰掉.当到达数组
末尾的时候再从头开始，直到最后剩余一个元素，写出算法，并输出最后保留的元素所在的最初的位置.

/**
 * 
 */
package arrayOperation;
/**
 * @author 花花
 *  用数组来实现， 定义并初始化一个（1--100）保存100个数的数组，
 *  从第一个元素开始，依次数(1,2,3 循环往复),每次数到到3的元素淘汰掉.
 *  当到达数组末尾的时候再从头开始，直到最后剩余一个元素，//怎么可能？最后会剩下两个元素吧
 *  写出算法，并输出最后保留的元素所在的最初的位置.
 *我觉得这个题很没有意思：模n,最后剩下的肯定就是前n-1个元素。如果只考虑结果的话，那么过程有点多余。
 */
public class Array_01 
{
    public static  void delete(int[] a,int n)
    {        
        int len=a.length;//记录一趟移动之后数组实际长度
        int l=0;//删除的元素个数
        while(len>n-1)
        {
            for(int i=n-1;i<len;i=i+n)//每一趟挑出当前数组中的无效元素
            {
                a[i]=0;//用0表示无效         
            }
            for(int i=0;i<len;i++)//将之前挑出的无效元素从当前数组中删除，更新数组
            {
                if(a[i]==0)
                {
                    for(int j=i;j<a.length-1;j++)
                    {
                        a[j]=a[j+1];//那么最后删除的元素值就都是a[length-1];             
                    }
                    l++;//删除的元素个数
                }       
            }
            len=a.length-l;//本趟结束后数组的有效长度
        }
        System.out.println("最后留下来的元素："+a[len-2]+","+a[len-1]);
        System.out.println("下标:"+(n-2)+","+(n-3));
    }
    public static void main(String[] args)
    {
        int[] a=new int[100];
        for(int i=0;i<100;i++)
        {
            a[i]=i+1;
        }
        delete(a,3);
        /*for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+"  ");
        }
        */
    }//方法main结束
}//类Array_01结束

这里写图片描述
3. 用数组来实现对于一个整形数组， 分别通过冒泡排序和 快速排序，实现对于任意一个数组进行由小到大的排列。

 /**
 * 
 */

package arrayOperation;
import java.util.Date;
/**
 * @author 花花
 * 用数组来实现对于一个整形数组， 分别通过冒泡排序和 快速排序，实现对于任意一个数组进行由小到大的排列。
 */
public class ArraySort 
{
    static int n=1;
    //先写个输出函数，偏于验证排序结果
    public static void printing(int[] a)
    {
        for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+"  ");
        }   
    }
    /*冒泡排序：每次将相邻两个数比较，如果不满足排序条件则交换位置
     * 比较次数：k>=n-1&&k<=(1/2)n(n-1)
     * 时间复杂度：O(n)<T(n)<O(n^2)
     * */    
    public static void bubbleSort(int[] a)
    {
        for(int i=0;i<a.length-1;i++)//控制排序趟数:最多n-1趟. 
        {
            int swap=0;//设置交换标志
            for(int j=0;j<a.length-i-1;j++)//控制比较次数。升序：每趟每次将相邻两个数比较,每趟从第n-i个到第n个元素已为升序排列
            {
                if(a[j]>a[j+1])//交换
                {
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                    swap=1;//有交换发生
                }               
            }//一趟完毕后，从第一个元素开始，每相邻两个元素，前一个元素小于后一个元素，即a[2k]>a[2k+1](k=1,2,3...n/2-1)  
            //输出每趟排序过程，可不写
            {
                System.out.print("\r第"+(i+1)+"趟:");//println本行输出之后再换行
                printing(a);
            }   
            if(swap==0)//本趟已有序,结束排序
            {
                break;
            }                        
        }//外层for结束      
    }//方法bubbleSort结束

    /*快速排序：核心算法：划分。
     * 任取其中一个记录（通常是第一个记录）为基准，
     * 经过一趟交换之后，所有关键字比它小的记录都交换到它的左边，所有关键字比它大的都交换到它的右边，
     * 此时，基准记录在序列中的最终位置就已经确定。
     * 然后再分别对划分到基准记录左右两部分区间的记录序列重复上述过程，直到每一部分最终划分为一个记录时为止。
     * 
     * */
    //划分算法：设置两个搜索指针i,j。起始时，i指向给定区间的第一个一个元素，j指向最后一个元素。对每个区间进行划分。
    public static int Partition(int[] a,int i,int j)
    {
        int key=a[i];
        int k1=i,k2=j;
        while(i<j)//控制排序趟数，当i>=j时，一趟排序完成
        {//每趟排序的扫描，交换过程
            while(i<j&&a[j]>=key)//当j找到的是比a[0]元素时，继续向前扫描，直到找到小于a[0]的元素后停止移动
            {
                j--;//j左移一位
            }
            if(i<j)//再次判断i,j的位置，
            {
                int temp=a[i];//交换a[i]和a[j]
                a[i]=a[j];
                a[j]=temp;
                i++;//i右移一位,因为i刚才的位置上的元素已经和j交换，存的是小于a[0]的元素，i向右移一位，到下一个元素，继续和a[0】比较
            }
            while(i<j&&a[i]<=key)//i自左向右移动，直到找到大于a[0]的元素时，停止移动
            {
                i++;//i右移一位             
            }
            if(i<j)//再次判断i,j的位置，
            {
                int temp=a[j];//交换a[i]和a[j]
                a[j]=a[i];
                a[i]=temp;
                j--;//j左移一位,因为j刚才的位置上的元素已经和a[i]交换，存的是大于a[0]的元素，j向左移一位，到下一个元素，继续和a[0】比较          
            }   
        }//while循环结束，一趟排序完成
        //输出每趟排序过程，可不写入算法
        {
            System.out.println("\r第"+n+"趟划分：");
            for(;k1<=k2;k1++)
            {
                System.out.print(a[k1]+" ");
            }
            n++;
        }

        return i;//返回基准记录a[0]最终存放的位置。便于确定下次划分位置。    
    }//方法Partition结束
    public static void QuickSort(int[] a,int s,int r)
    {
        int i;
        if(s<r)
        {
            i=Partition(a,s,r);//本趟结束后，基准记录的最终位置
            QuickSort(a,s,i-1);//对基准记录的左区间再次进行划分
            QuickSort(a,i+1,r);//对基准记录的右区间再次进行划分
        }
    }   
    public static void main(String[] args)
    {
        /*int[] a=new int[100];
        for(int i=100;i>0;i--)
        {
            //a[i]=(int)(Math.random()*100)+1;
            a[100-i]=i;
        }*/
        int[] a= {1,4,2,8,5,1};
        System.out.println("初始序列:");
        printing(a);
        System.out.print("\rbubbleSort比较过程：");
        //Date bubbleTime1=new Date();
        bubbleSort(a);
        //Date bubbleTime2=new Date();
        System.out.println("\rbubbleSort排序结果：");
        printing(a);
        //System.out.printf("\rbubbleSort排序时间：%1$dms",(bubbleTime2.getTime()-bubbleTime1.getTime()));

        int[] b= {1,4,2,8,5,1};
        int[] c=new int[100];
        for(int i=100;i>0;i--)
        {
            //c[i]=(int)(Math.random()*100)+1;
            c[100-i]=i;
        }
        System.out.print("\r\r初始序列：\r");
        printing(b);
        System.out.print("\rQuickSort比较过程：");
        //Date QuickTime1=new Date();
        QuickSort(b,0,5);
        //Date QuickTime2=new Date();
        System.out.println("\rQuickSort排序结果：");
        printing(b);
        //System.out.printf("\rQuickSort排序时间：%1$dms",(QuickTime2.getTime()-QuickTime1.getTime()));             
    }//方法main结束
}//类ArraySort结束

运行结果：
这里写图片描述
4.判断101-200之间有多少个素数，并输出所有素数。

 /**
 * @author 花花
 *判断101-200之间有多少个素数，并输出所有素数
 */
public class SuShu 
{
    public static void main(String[] args)
    {
        for(int i = 101;i<=200;i++)
        {
            boolean isPrime = true;
            for(int j = 2; j <= Math.sqrt(i); j++)
            {
                if(i % j == 0)
                {
                    isPrime = false;
                    break;
                }
            }       
            if(isPrime)
            {
                System.out.print(i + ", ");
            }                   
        }
    }
}

运行结果：

这里写图片描述
5.题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

 /**
 * 
 */
package tt;
import java.util.*;
/**
 * @author 花花
 *输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
 *英文字母：'A'~'z':65~90,97~122.
 *数字:
 */
public class DateEstimate
{
    public static void main(String[] args)
    {
        int countChar=0;//字母
        int countNumber=0;//数字
        int countOther=0;//其他字符
        int countNull=0;//空格
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();
        for(int i=0;i<str.length();i++)
        {
            char c=str.charAt(i);
            if((c>='A'&&c<='Z')||(c>='a'&&c<='z'))
            {
                countChar++;
            }
            else if(c>='0'&&c<='9')
            {
                countNumber++;
            }
            else if(c==' ')
            {
                countNull++;
            }
            else
            {
                countOther++;
            }           
        }
        System.out.println("字母的个数为："+countChar);
        System.out.println("数字的个数为："+countNumber);
        System.out.println("空格的个数为："+countNull);
        System.out.println("其它字符的个数为："+countOther);
    }


}

这里写图片描述
6.题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，
高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，
高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润，求应发放奖金总数？

 /**
 * 
 */
package noName;
import java.util.*;
/**
 * @author 花花
 *企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，
高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，
高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润，求应发放奖金总数？
 */
public class JudgePrize 
{
    float prize;//奖金数
    float profit;//利润
    //输入利润
    JudgePrize()
    {
        System.out.println("请输入利润（万元）：");
        Scanner ss=new Scanner(System.in);
        profit=ss.nextFloat();
        prize=countPrize(profit);
    }//构造方法JudgePrize结束
    //根据利润判断奖金
    public float countPrize(float profit)
    {   
        if(profit<=10)
        {
            prize=profit*0.1f;          
        }
        else if(profit>10&&profit<=20)
        {
            prize=(countPrize(10)+(profit-10)*0.075f);
        }
        else if(profit>20&&profit<=40)
        {
            prize=(countPrize(20)+(profit-20)*0.05f);
        }
        else if(profit>40&&profit<=60)
        {
            prize=(countPrize(40)+(profit-40)*0.03f);
        }
        else if(profit>60&&profit<=100)
        {
            prize=(countPrize(60)+(profit-60)*0.015f);
        }
        else if(profit>100)
        {
            prize=(countPrize(100)+(profit-100)*0.01f);
        }
        else
        {
            System.out.println( "您输入的数据有误！");   
        }       
        return prize;
    }
    public static void main(String[] args)
    {
        JudgePrize jp=new JudgePrize();     
        System.out.println("应发放的奖金数为："+jp.prize+"万元");      
    }//方法main结束 
}//类JudgePrize结束

运行结果：
这里写图片描述
7.分别定义用户类，订单类，产品类，其中订单类至少要具有下订单的行为(入参为一个产品名称)，
产品类中至少有一个成员变量为产品名称，至少有一个方法用来获取产品的名称。
用户类中持有一个产品类型的成员变量。
用户类中持有一个订单类型的成员变量。

在我们的用户类中定义main函数，当执行的时候，构造一个用户类的对象，
并且通过手段可以拿到产品成员变量中的产品名称，并且调用成员变量订单的对象，进行下单。
最后输出下单成功。

 /**
 * 
 */
package seven;
import java.util.*;
/**
 * @author 花花
 * 简介：用户类
 *用户类中持有一个产品类型的成员变量。
  用户类中持有一个订单类型的成员变量。

  在我们的用户类中定义main函数，当执行的时候，构造一个用户类的对象，
  并且通过手段可以拿到产品成员变量中的产品名称，并且调用成员变量订单的对象，进行下单。
  最后输出下单成功。
 */
public class User 
{
    private int[] ID=new int[6];//用户ID
    private String name;//用户名
    User()
    {
        Scanner in=new Scanner(System.in);
        for(int i=0;i<6;i++)//自动生成用户ID
        {
         ID[i]=(int)(Math.random()*10);
        }
        System.out.println("请输入您的用户名");
        name=in.next();

    }
    public String getName()
    {
        return name;
    }
    public int[] getID()//返回用户ID
    {
        return ID;
    }
    public void userOrder(Order a,Product p)//用户下单
    {
        a.Order(this,p);
        //a.printOrder();//输出订单信息
    }
    public static void main(String[] args) 
    {
        User a=new User();
        Order b=new Order();
        System.out.println("请输入要购买的商品信息：");
        Product p1=new Product();
        a.userOrder(b,p1);
        System.out.println("还要继续购买吗？是？否？");
        Product[] p=new Product[9];
        Scanner in=new Scanner(System.in);
        String str=in.next();
        for(int i=0;str.equals("是")&&i<9;i++)//while(str.equals("是")&&pSum>0)
        {
            p[i]=new Product();
            a.userOrder(b,p[i]);
            System.out.println("还要继续购买吗？是？否？");
            Scanner s=new Scanner(System.in);
            str=s.next();
        }
        b.printOrder(); 
        b.menuOrder(b);
    }
}//类User结束

/**
 * 
 */
package seven;

import java.util.Scanner;

/**
 * @author 花花
 *简介：订单类
 *订单类至少要具有下订单的行为(入参为一个产品名称)
 */
public class Order
{
    int[] ID=new int[13];//订单号
    String orderUser;//订单用户
    static float sumPrice=0;//订单总价
    int[] userID=new int[6];
    //String[] merName=new String[10];
    static int t=0;//商品种类数量
    boolean pay=false;//付款状态
    Product[] pt=new Product[10];//用户要购买的商品种类,一笔订单最多10种商品 
    Order()
    {
        for(int i=0;i<13;i++)//自动生成订单号
        {
         ID[i]=(int)(Math.random()*10);
        }
    }
    public void Order(User a,Product p)//下单
    {   
        orderUser=a.getName();   
        sumPrice=sumPrice+p.sumPrice;        
        userID=a.getID();
        if(t<=10)
        {
            pt[t]=p;
        }   
        t++;//商品数加一
    }
    public void reviceOrderProduct()//修改订单中指定的商品的数量
    {
        System.out.println("请输入要修改的商品名");
        Scanner s=new Scanner(System.in);
        String pname=s.next();
        boolean flag=false;
        for(int i=0;i<t;i++)
        {
            if((pt[i].name).equals(pname))
            {
                System.out.println("请输入要修改的商品数量");
                Scanner s1=new Scanner(System.in);
                int n=s1.nextInt();
                sumPrice=sumPrice-pt[i].sumPrice;
                pt[i].reviseProduct(n);
                sumPrice=sumPrice+pt[i].sumPrice;
                flag=true;
                System.out.println("修改成功！");
            }
        }
        if(!flag)
        {
            System.out.println("无对应商品！");
        }
    }
    public void deleteProduct()//删除订单中指定的某个商品
    {
        int temp=t;
        System.out.println("请输入要删除的商品名");
        Scanner s=new Scanner(System.in);
        String pname=s.next();
        boolean flag=false;
        for(int i=0;i<temp;i++)
        {
            if((pt[i].name).equals(pname))
            {
                //删除
                sumPrice=sumPrice-pt[i].sumPrice;
                pt[i]=pt[i+1];
                t--;
                flag=true;
                System.out.println("删除成功！");
            }
        }
        if(!flag)
        {
            System.out.println("无对应商品！");
        }   
    }
    public void menuOrder(Order d)
    {
        System.out.println( "请输入您的选择：");
        System.out.println("1-付款  2-修改当前订单信息  3-取消订单 0-保存");
        Scanner s=new Scanner(System.in);
        int n=s.nextInt();
        if(n==1)
        {
           pay=true;//完成付款  
           System.out.println("您已完成付款！");
        }
        else if(n==2)
        { 
            System.out.println("1-删除商品  2-修改商品数量");
            Scanner s2=new Scanner(System.in);
            int n2=s2.nextInt();
            if(n2==1)
            {
                this.deleteProduct();
                menuOrder(d);

            }
            else
            {
                this.reviceOrderProduct();
                menuOrder(d);
            }           
        }
        else if(n==3)
        {
            d=null;//d会被当成垃圾回收
            System.out.println("您已成功取消订单！");         
        }
        else
        {
            d.printOrder();
        }
    }           
    public void printOrder()//打印订单信息
    {
        System.out.println("当前订单信息:");
        System.out.print("订单号：");
        for(int i=0;i<13;i++)
        {
            System.out.print(ID[i]);
        }
        System.out.println("\r用户名："+orderUser); 
        System.out.print("用户ID：");
        for(int i=0;i<6;i++)
        {
            System.out.print(userID[i]);
        }
        System.out.println("\r商品列表：");
        for(int i=0;i<t;i++)
        {
           pt[i].printProduct(); 
        }
        System.out.println("\r订单总价："+sumPrice);
        System.out.print("付款状态：");
        if(pay)
        {
            System.out.println("已付款");
        }
        else
        {
            System.out.println("待付款");
        }
    }
}

/**
 * 
 */
package seven;
import java.util.*;
/**
 * @author 花花
 *简介：产品类
 * 产品类中至少有一个成员变量为产品名称，至少有一个方法用来获取产品的名称。
 */
public class Product 
{
    String name;//产品名
    float price;//单价
    int amount=0;
    float sumPrice=0; 
    Product()
    {
        Scanner in=new Scanner(System.in);
        System.out.println("请输入商品名：");
        name=in.next();
        System.out.println("请输入商品单价：");
        price=in.nextFloat();
        System.out.println("请输入要购买商品数量：");
        amount=in.nextInt();
        sumPrice=amount*price;
    }
    public void reviseProduct(int n)//修改商品数量
    {
        amount=amount+n;
        sumPrice=amount*price;
    }
    public void printProduct()
    {
        //System.out.println("商品信息:");
        System.out.println("商品名："+name);
        System.out.println("单价："+price);
        System.out.println("数量："+amount);
        System.out.println("总价："+sumPrice);
    }   
}

运行结果：
输入。
修改订单：修改订单中商品数量，删除商品。
保存订单。
这里写图片描述
这里写图片描述此图和第一幅图是相连的。
这里写图片描述此图和第二幅图是相连的
付款：
这里写图片描述
取消订单：
这里写图片描述
只是做了单个用户下订单的功能，其中要是利用文件展现已有的商品列表，供用户选择更好。而且采用数据库表的形式存储代替数组会更好好。可以建三张表：用户表，订单表，商品表。

秋小苒
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java面试基础 P2
zlhcsm的博客
09-30 327
文章目录1，实例变量、局部变量、类变量和final变量2，构造函数3，==、equals和hashcode()4，final关键字5，finalize()图解6，String底层7，线程状态转换图8，内存分配策略9，JVM中的堆和栈10，堆和栈优缺点比较11，不同数据类型存储12，String在内存中的存放12，数组在内存中的存放13，static变量在内存中的存放14，java中变量在内存中的分...
Java p2
remain_genuine的博客
09-25 275
201711671126 《Java程序设计》 第1周学习总结 教材学习内容总结 2.2基本数据类型 逻辑类型 整数类型 1.int型 2.byte型 3.short型 4.long型 字符类型 浮点类型 1.float型 2.double性 2.3类型转化运算 数据转换：当把一种基本数据类型变量的值赋给另一种基本类型变量时； 级别低的变量值赋给级别高的时，系统自动完...
java 快排练习
fengyun703的专栏
11-18 317
快排思路：取一个元素作为key，把数组分成两部分，一部分大于key，一部分小于key，key值在中间。在对前后两部分递归的使用该步骤。 编程思路，取第一做key，从右边找比key小的，进行交换；记录key所在位置，再从左边找比key大的，与key交换。以此反复。 public class QuickSort { public static void main(String[] arg
java入门（p2）进入java的世界
weixin_33969116的博客
02-12 158
浅谈java世界（连载中P2） 前回说完java的基本特点之后，做一个补充，java的语言特性，这个记住就行了，write-once+run-anywhere（理解就好，大概就是写一次哪儿都能用） 这回讲java的程序结构 这个时候要理解一些词汇：1.source file(源文件) 2.class（类） 3.method（方法） 4,...
【Java】P2 基础语法与运算符
最新发布
weixin_43098506的博客
03-02 268
Java 注释方法，驼峰命名法，基本运算与基本数据类型，隐式转换，逻辑运算符与短路逻辑运算符，三元运算符
TDT4186-P2:练习 P2
06-22
“P2”可能代表项目阶段，而“TDT4186-P2-master”可能表示这是一个使用Maven管理的Java项目。Maven是Apache软件基金会的一个项目，它提供了一种标准化的方式来构建和管理Java项目。Maven使用Project Object Model ...
random-p2p:p2p练习模块5
05-25
在深入学习这个项目之前，确保你具备基本的JavaScript知识，理解变量、函数、控制流以及数组和对象等概念。对于P2P网络，了解其基本原理，如BitTorrent的工作方式，以及对等节点间如何交换数据，将有助于更好地理解...
SimpliCity-P2:与灰烬一起练习
05-06
简单本自述文件概述了与此Ember应用程序进行协作的细节。 此应用程序的简短介绍可以轻松地转到此处。先决条件您需要在计算机上正确安装以下物品。 （带有NPM）安装git clone 此存储库切换到新目录npm install bower ...
CA-P2:计算机应用程序分配2
05-14
2. **类与对象**：Java的核心是面向对象编程，你需要理解类的定义、对象的创建和操作。这包括封装、继承和多态等概念。封装使得代码更易于管理和维护，继承允许子类共享父类的属性和行为，多态则增强了代码的灵活性...
Java-programming-exercises:Java程序
04-17
Java编程练习 使用&&的年龄控制应用程序 使用||进行考试结果报名 银行申请书P1 银行申请P2 银行申请最终代码 交换两个数字 Java方法 访问类别（文件夹） 抽象化 构造函数抽象 算术运算 方法重载 查找素数 嘶嘶声
P2、JAVA 基础_语法及其注释
猪猪的博客
08-24 160
一、基础语法 public class Demo { public static void main(String[] args) {//main方法 System.out.println("Hellow World!"); } } 二、三种注释 单行注释 //这是单行注释 快捷键：ctrl+/ 多行注释 /* 这是多行注释 这是多行注释 这是多行注释*/ 文本注释 /** *
【牛客网】直通bat-面试算法精品课_第2章 排序 2.6 快速排序练习题（JAVA版）
wubinyu的专栏
09-28 302
对于一个int数组，请编写一个快速排序算法，对数组元素排序。 给定一个int数组A及数组的大小n，请返回排序后的数组。 测试样例： [1,2,3,5,2,3],6 [1,2,2,3,3,5]
Java习题——面向对象综合练习题
Sunshine的博客
07-12 2万+
1.编写出一个通用的人员类（Person），该类具有姓名（Name）、年龄（Age）、性别（Sex）等域。然后对Person 类的继承得到一个学生类（Student），该类能够存放学生的5门课的成绩，并能求出平均成绩。最后在Main函数中对student类的功能进行验证。 package cn.edu.nefu.exercise1; /*1.编写出一个通用的人员类（Person），该类具有姓名...
用java实现一个简单的p2p连接以及stun NAT探测
wobupeiai的博客
07-08 6947
        网上有很多相关的理论都大同小异，但java实现的不多，我就实现了一下，其实是没有什么意义的，只是因为提高一下编程水平，而且我还没有条件去做实验，因为这里要用到两个外网ip，所以代码到底行不行不一定，但是我觉得应该能行！至少理论实现上是对的。。。好吧，我还是不确定。        具体实现全程都是用UDP来进行的，因为tcp需要三次握手连接，发送完随时都会关闭，关闭就不能发送了，而p...
java p2p实例_java文件p2p传输
weixin_39980841的博客
02-13 978
【实例简介】java模仿电驴、迅雷实现多线程文件传输，可用于局域网或internet文件传输发送，程序采用套接字实现p2p(即点到点)文件传输。【实例截图】【核心代码】java文件p2p传输└── java文件p2p传输├── classes│ ├── package cache│ │ └── trans.dep2│ └── trans│ ├── Application...
p2p技术之tcp内网穿透 java实现版
热门推荐
印链(Inchain) 的技术博客
02-25 2万+
如今p2p技术已经十分成熟，然而很多人停留在理论层面，在实现过程中遇到这样那样的问题，甚至有的人说tcp打洞无法实现，本文简单阐述tcp穿透的过程，然后附上完整的java代码。
java上机练习1答案_Java基础练习选择题(1)答案
weixin_34026053的博客
02-27 6060
JDK是( )A、一种全新的程序语言B、一种程序开发辅助工具C、一种由Java写成的，并支持Java Applet的浏览器D、一种游戏软件2、Java语言中下面哪个可以用作正确的变量名称( )A、3D B、name C、extends D、implements3、构造函数何时被调用( )A、类定义时 B.创建对象时C.调用对象方法时...
Java中数组用做参数以及数组用做返回值
Gaoju12138的博客
10-20 519
1、数组用做方法的参数 public static void main(String[] args) { int[] array = {10, 20, 30, 40, 50}; printArray(array); } public static void printArray(int[] array) { for (int i = 0; i < array.length; i++) { System.out.println(array[i]); } }
腾讯云X-P2P：实时直播的高效解决方案
本文档深入探讨了"面向实时直播的P2P技术实现"，由腾讯云的崔立鹏撰写，主要关注在实时流媒体行业中如何通过P2P（ Peer-to-Peer）技术提高效率并优化用户体验。随着行业的发展，用户对高清画质和流畅播放体验的需求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值