java算法比较

⑴ java 比较大小算法

排序用建议实现comparable类吧 自定义排序比较的参数 否则对象是没法比较大小的 只能比较是否相等
class One implements Comparable{
int age;

@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
One one = (One)o;
if(one.age > this.age)
return -1;
else if( one.age < this.age)
return 1;
else
return 0;
}
}
大概这个意思 这是对象比较大小
对象数组同样也这样比较，数值数组直接循环比较就行

⑵ 求一个比较大小的JAVA算法

1.是的
2.a-可以直接求和，b-利用近似公式
3.近似公式为e=(1+1/n)^n,n->无穷大
4.这两个公式都需要运算n到足够大来减少误差
假如你运算到n=k满足精度需要了
那么你首先要保证当n=k-1时算出的值与n=k的值差别小于0.0001
假如需要考虑截断误差，那么你就要考虑到任何一个1/n或者1/n!的形式的截断误差，以及运算中每一步的累计误差，都是可以计算的
从累积误差的角度来说，第一个方法较优
因为每一个求和项目都是整数的倒数，只发生一次截断
之后的误差计算直接将最大误差可能求和就可以了
而且每一次迭代可以应用上一次的结果，效率较高
但是缺点是当n比较大的时候，n!也会是一个比较大的数，n的类型定义得不好会溢出
第二个方法就需要计算一次截断误差，并且计算n次方的误差累积

⑶ java算法有哪些分别

您好：

java中的算法，常见的有：递归、迭代、查找、排序（包含冒泡排序、选择排序、插入排序、快速排序四种） 等，算法有很多，一般数据结构中涉及到的都可以用java语言实现。

举几个例子：

1.递归的例子：

不一一举例，仅供参考！

⑷ JAVA使用什么加密算法和解密算法好

简单的Java加密算法有：
第一种. BASE
Base是网络上最常见的用于传输Bit字节代码的编码方式之一，大家可以查看RFC～RFC，上面有MIME的详细规范。Base编码可用于在HTTP环境下传递较长的标识信息。例如，在Java Persistence系统Hibernate中，就采用了Base来将一个较长的唯一标识符（一般为-bit的UUID）编码为一个字符串，用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中，也常常需要把二进制数据编码为适合放在URL（包括隐藏表单域）中的形式。此时，采用Base编码具有不可读性，即所编码的数据不会被人用肉眼所直接看到。
第二种. MD
MD即Message-Digest Algorithm （信息-摘要算法），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD的前身有MD、MD和MD。广泛用于加密和解密技术，常用于文件校验。校验？不管文件多大，经过MD后都能生成唯一的MD值。好比现在的ISO校验，都是MD校验。怎么用？当然是把ISO经过MD后产生MD的值。一般下载linux-ISO的朋友都见过下载链接旁边放着MD的串。就是用来验证文件是否一致的。
MD算法具有以下特点：
压缩性：任意长度的数据，算出的MD值长度都是固定的。
容易计算：从原数据计算出MD值很容易。
抗修改性：对原数据进行任何改动，哪怕只修改个字节，所得到的MD值都有很大区别。
弱抗碰撞：已知原数据和其MD值，想找到一个具有相同MD值的数据（即伪造数据）是非常困难的。
强抗碰撞：想找到两个不同的数据，使它们具有相同的MD值，是非常困难的。
MD的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩”成一种保密的格式（就是把一个任意长度的字节串变换成一定长的十六进制数字串）。除了MD以外，其中比较有名的还有sha-、RIPEMD以及Haval等。
第三种.SHA
安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于^位的消息，SHA会产生一个位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善，并被广泛使用。该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。
SHA-与MD的比较
因为二者均由MD导出，SHA-和MD彼此很相似。相应的，他们的强度和其他特性也是相似，但还有以下几点不同：
对强行攻击的安全性：最显着和最重要的区别是SHA-摘要比MD摘要长 位。使用强行技术，产生任何一个报文使其摘要等于给定报摘要的难度对MD是^数量级的操作，而对SHA-则是^数量级的操作。这样，SHA-对强行攻击有更大的强度。
对密码分析的安全性：由于MD的设计，易受密码分析的攻击，SHA-显得不易受这样的攻击。
速度：在相同的硬件上，SHA-的运行速度比MD慢。
第四种.HMAC
HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证等。

⑸ java如何比较一维数组大小

boolean isEqual(int[] a, int b[])
{
int n = a.length;

if(n != b.length) //数组长度销耐不相等 返回false
return false;

for(int i =0 ;i <n;i++)
{
if(a[i] != b[i]) //对应元素不尘斗竖相派大等 返回false
{
return false;
}
}

return true; //长度相等 对应元素也相等 返回true
}
}

⑹ java三个数排序比较大小的完整代码，并给出详细解释，初学者，谢谢

import java.util.Arrays;

import java.util.Collection;

public class Demo2 {

public static void main(String[] args) {

// 这是你的三个数

int[] arr = { 12, 32, 18 };

// 两层嵌套循环

for (int i = 0; i < arr.length; i++) {

for (int j = 0; j < i; j++) {

// 如果后者小于前者，让他们交换位置，一直循环

// 直到每个数字都从头到尾跟数组里的每个数字比较一次

if (arr[i] < arr[j]) {

// 这三步就是交换位置，相信聪明的你一定看得懂了

arr[i] = arr[i] + arr[j];

arr[j] = arr[i] - arr[j];

arr[i] = arr[i] - arr[j];

}

}

}

//最后打印出来

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

}

}

资料拓展：

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论

⑺ java中的算法，一共有多少种，哪几种，怎么分类。

就好比问，汉语中常用写作方法有多少种，怎么分类。

算法按用途分,体现设计目的、有什么特点
算法按实现方式分，有递归、迭代、平行、序列、过程、确定、不确定等等
算法按设计范型分，有分治、动态、贪心、线性、图论、简化等等

作为图灵完备的语言，理论上”Java语言“可以实现所有算法。
“Java的标准库'中用了一些常用数据结构和相关算法.

像apache common这样的java库中又提供了一些通用的算法

⑻ Java单多线程求pair值算法比较

• 单线程比多线程更快。你的测试代码只是用了CPU资源。因为多线程需要处理线颤改程的开销，开销多了自然没有单线程快。

• 多线程是为了更充分的利用计算机的资源。比如网络,IO,CPU...如果你在for循环里芹洞此加入一个磁盘写入操作，多嫌迅线程就会比单线程快了

⑼ java十大算法

算法一：快速排序算法
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

算法步骤：

1 从数列中挑出一个元素，称为 "基准"（pivot），

2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

算法二：堆排序算法
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

堆排序的平均时间复杂度为Ο(nlogn) 。

算法步骤：

创建一个堆H[0..n-1]

把堆首（最大值）和堆尾互换

3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置

4. 重复步骤2，直到堆的尺寸为1

算法三：归并排序
归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

算法步骤：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置

3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

4. 重复步骤3直到某一指针达到序列尾

5. 将另一序列剩下的所有元素

⑽ Java单多线程求pair值算法比较

进程和线程的概念

什么是进程

一个进程就是在一个运行的程序 它有自己独立的内存空间 一组系统资源 每个进程的内部数据和状态都是独立的 例如在window是同时打开多个记事本 虽然它们所运行的程序代码都是一样的 但是所使用的内存空间是独立的 互不干扰

什么是线程

线程与进程相似 是一段完成某个特定功能的代码 是程序中单个顺序的流控制;但与进程不同的是 同类的多个线程共享一块内存空间和一组系统资源 而线程本身的数据通常只有微处理器的寄存器数据 以及一个供程序执行时使用的堆栈

进程与线程的区别

进程:每个进程都有独立的代码和数据空间(进程上下文) 进程切换的开销大

线程:轻量的进程 同一类线程共享代码和数据空间 每个线程有独立的运行栈和程序计数器(PC) 线程切换的开销小

多进程:在操作系统中 能同时运行多个任务程序

多线程:在同一应用程序中 有多个顺序流同时执行

线程创竖态梁建的两种方式

采用继承Thread类创建线程

该方法比较简单 主要是通过继承java lang Thread类 并覆盖Thread类的run()方法来完成线成的创建 Thread 类是一个具体的闭悄类 即不是抽象类 该类封装了线程的行为 要创建一个线程 程序员必须创建一个从 Thread 类导出的新类 Thread类中有两个最重要的函数run()和start()

通过实现Runnable接口创建线程

该方法通过生成实现java lang Runnable接口的类 该接口只定义了一个方法run() 所以必须余运在新类中实现它 但是 Runnable 接口并没有任何对线程的支持 我们还必须创建 Thread 类的实例 这一点通过 Thread 类的构造函数

public Thread(Runnable target);来实现

单线程和多线程性能比较

以使用蒙特卡罗概率算法求π为例 进行单线程和多线程时间比较

什么是蒙特卡罗概率算法

蒙特卡罗法(Monte Carlo method)是以概率和统计的理论 方法为基础的一种计算方法 将所求解的问题同一定的概率模型相联系 用电子计算机实现统计模拟或抽样 以获得问题的近似解 故又称统计模拟法或统计试验法 网络

蒙特卡罗求算法求π

第一步

画正方形和内切圆

第二步

变换表达式

正方形面积As=( R)^

圆的面积Ac=πR^

Ac/As=( R)^ /πR^

π= As/Ac

令P=As/Sc 则π= P

第三步

重复N次实验求平均值

在正方形区域内随机生成一个点A 若A落在圆区域内 M++

P=M/N

π= P N的取值越大 π的值越精确

java代码实现算法

N取值为 万 多线程的数为 每个线程执行 万次模拟实验

线程实现

import ncurrent CountDownLatch;

public class ProModel implements Runnable {

public int N;//随机实验的总次数

public static int M;//随机点落在圆中的次数

private int id;

private final CountDownLatch doneSignal;

OBJ semaphore;

public ProModel(int id CountDownLatch doneSignal int N OBJ semaphore ){

this id=id;

this doneSignal=doneSignal;

this N=N;

this semaphore=semaphore ;

M= ;

}

public void run(){

int tempM= ;

for(int i= ;i<N;i++){

if(isInCircle()){

tempM++;

}

}

synchronized (semaphore) {

add(tempM);

}

untDown();//使end状态减

}

public void add(int tempM){

System out println(Thread currentThread() getName());

M=M+tempM;

System out println(M);

}

//随机产生一个在正方形区域的点 判断它是否在圆中

public boolean isInCircle(){

double x=Math random();

double y=Math random();

if((x )*(x )+(y )*(y )< )

return true;

else

return false;

}

public static int getTotal(){

return M;

}

}

多线程Main实现

import ncurrent CountDownLatch;

import ncurrent ExecutorService;

import ncurrent Executors;

public class MutliThread {

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

long begin=System currentTimeMillis();

int threadSize= ;

int N= ;

OBJ semaphore = new OBJ();

CountDownLatch doneSignal = new CountDownLatch(threadSize);

ProModel[] pros=new ProModel[threadSize];

//设置特定的线程池 大小为threadSizde

System out println( begins! );

ExecutorService exe = Executors newFixedThreadPool(threadSize);

for(int i= ;i<threadSize;i++)

exe execute(new ProModel(i+ doneSignal N semaphore));

try{

doneSignal await(); //等待end状态变为 }catch (InterruptedException e) {

// TODO: handle exception

e printStackTrace();

}finally{

System out println( ends! );

System out println( *(float)ProModel getTotal()/(float)(threadSize*N));

}

exe shutdown();

long end=System currentTimeMillis();

System out println( used time(ms): +(end begin));

}

}

class OBJ{}

单线程Main实现

import ncurrent CountDownLatch;

import ncurrent ExecutorService;

import ncurrent Executors;

public class SingleThread {

public static void main(String[] args) {

long begin=System currentTimeMillis();

int threadSize= ;

int N= ;

OBJ semaphore = new OBJ();

CountDownLatch doneSignal = new CountDownLatch(threadSize);

ProModel[] pros=new ProModel[threadSize];

//设置特定的线程池 大小为

System out println( begins! );

ExecutorService exe = Executors newFixedThreadPool(threadSize);

for(int i= ;i<threadSize;i++)

exe execute(new ProModel(i+ doneSignal N semaphore));

try{

doneSignal await(); //等待end状态变为 }catch (InterruptedException e) {

// TODO: handle exception

e printStackTrace();

}finally{

System out println( ends! );

System out println( *(float)ProModel getTotal()/(float)(threadSize*N));

}

exe shutdown();

long end=System currentTimeMillis();

System out println( used time(ms): +(end begin));

}

}

运行结果比较