如何实现
① 用Java怎么实现
1、如下例子是可以输入n个正整数，从中选出最大值和最小值。
publicclassMaxMin{
publicstaticvoidmain(String[]args){
int[]arr=newint[3];
Scannerinput=newScanner(System.in);
for(inti=0;i<arr.length;i++){
System.out.println("请输入第"+(i+1)+"个数字:");
intnumber=input.nextInt();
arr[i]=number;
}
intsum=0,min=arr[0],max=min;
for(inti=0;i<arr.length;i++){
sum+=arr[i];
if(min>arr[i]){
min=arr[i];
}
if(max<arr[i]){
max=arr[i];
}
}
System.out.println("最大值："+max);
System.out.println("最小值："+min);
}
}2、代码中第2行创建数组传入的是3，就是你的题目所需。如果你题目里不是3，而是其他按数字，则可以在第2行中进行修改即可。
② 如何实现
<!doctypehtml>
<html>
<head>
<metacharset="utf-8">
<title>Email格式验证并在后方输出</title>
<scripttype="text/javascript">
functioncI(str){
document.getElementById("mess").innerHTML=str;
}
functioncheck()
{
varstr=document.getElementById("email").value;
if(str!=""&&str.indexOf("@")!=-1&&
str.match(/^([a-zA-Z0-9_.-])+@(([a-zA-Z0-9-])+.)+([a-zA-Z0-9]{2,4})+$/)){
//你可以将下面字符串中改成图片
cI("<fontcolor='green'>√</font>");
}else{
//这个可以对应错误的图片
cI("<fontcolor='red'>×</font>")
}
}
</script>
</head>
<body>
<label>email验证
<inputtype="text"id="email"onBlur="check()"/><spanid="mess"></span>
</label>
</body>
</html>
上面的是一个比较完整的HTML代码范例，只要在输入框中录入完邮件，当焦点失去后便会对录入结果进行验证。
代码中标示着注释，你可以按照注释修改；
实现的过程可以说是一目了然，你分析一下，很容易就能够插入到你自己的代码中去。
③ 如何实现自己的理想
一位名叫薛瓦勒的乡村邮差每天徒步奔走在乡村之间。有一天，他在崎岖的山路上被一块石头绊倒了。
他起身，拍拍身上的尘土，准备再走。可是他突然发现绊倒他的那块石头的样子十分奇异。他拾起那块石头，左看右看，便有些爱不释手了。
于是，他把那块石头放在了自己的邮包里。村子里的人看到他的邮包里除了信之外，还有一块沉重的石头，感到很奇怪，人们好意地劝他：“把它扔了，你每天要走那么多路，这可是个不小的负担。”
他却取出那块石头，炫耀着说：“你们谁见过这样美丽的石头?”
人们都笑了，说：“这样的石头山上到处都是，够你捡一辈子的。”
他回家后疲惫地睡在床上，突然产生了一个念头，如果用这样美丽的石头建造一座城堡那将会多么迷人。于是，他每天在送信的途中寻找石头，每天总是带回一块，不久，他便收集了一大堆奇形怪状的石头，但建造城堡还远远不够。
于是，他开始推着独轮车送信，只要发现他中意的石头都会往独轮车上装。
从此以后，他再也没有过上一天安乐的日子，白天他是一个邮差和一个运送石头的苦力，晚上他又是一个建筑师，他按照自己天马行空的思维来垒造自己的城堡。
对于他的行为，所有人都感到不可思议，认为他的精神出了问题。
20多年的时间里，他不停地寻找石头，运输石头，堆积石头，在他的偏僻住处，出现许多错落有致的城堡，有清真寺式的，有印度神教式的，有基督教式的……当地人都知道有这样一个性格偏执沉默不语的邮差，在干一些如同小孩子筑沙堡的游戏。
1905年，法国一家报社的记者偶然发现了这群低矮的城堡，这里的风景和城堡的建筑格局令他叹为观止。他为此写了一篇介绍薛瓦勒的文章，文章刊出后，薛瓦勒迅速成为新闻人物。许多人都慕名前来参观城堡，连当时最有声望的毕加索也专程参观了薛瓦勒的建筑。
现在，这个城堡成为法国最著名的风景旅游点，它的名字就叫做“邮差薛瓦勒之理想宫”。
通过一块绊脚石的启发，树立了一个远大的理想，经过一生的辛苦努力最后终于获得了最大成功，同时也告诉我们有志者事竟成。
④ 如何能够实现自己的目标
先来说说我们经常会遇到需要定目标的时候，似乎每到这个时刻，我们总是信誓旦旦的写下自己要完成的目标。然而，前几天特别的坚定的自己似乎几天后，一个月后，两个月后已经不记得自己曾经说过的话了。
回想之前上班的公司，年初的时候让我们定下年末要实现的目标。当时我们总能大放厥词的说要买房，买车等等……把自己的目标能写的都写在纸上。然后后面当我问起我的一些同事，大多数的回答都是快忘了自己有写过这份目标单了。
1.为什么我们会遗忘掉我们的目标？
我们都知道什么叫目标？大概的意思就是通过我们的努力未来能够实现的事情，能够获得的事物。大家都知道未来是有一个期限的，比如一个月，一年，两年，甚至五年。所以在我们短期没有看到效果的时候，我们就会容易遗忘掉我们曾经说过的话，许下的诺言。就如同我们跟父母说要考上师范，考上北大，结果只上了一个大专。我们给了目标一个期限，却没有想过要怎么实现它。
2.如何实现自己的目标？
这里给大家分享一个思维叫做【目标倒推思维】。我为什么要要分享这个思维给你们，因为你只要理解并且狠狠执行【目标倒推思维】，那么这个思维将让你收益终身。
既然这个思维用处那么大，那么什么叫【目标倒推思维】呢？简单来说通过【目标倒推思维】把我们的目标通过时间拆分开来，细化聚焦到每一天。有些人说我不懂拆分啊？别着急，这里给你举个例子，看完就会明白。
我们先来看下面这张表格：
（一年按250天计算）
年赚10万=日赚400元
年赚20万=日赚800元
年赚50万=日赚2000元
年赚100万=日赚4000元
假设我们定的目标是年赚10万元。那么
第一步：年赚10万=月赚8330=日赚400元
第二步：如何日赚400元？
做一单利润400元的，或者做2单利润200元的
第三步：如何每天卖出去2单产品呢？
假设你的成交率是2%，那么你需要每天100个流量
第四步：如何每天获得100个流量？
我们可以通过互联网流量或者微信流量各种渠道去获得。
那么这样拆分开来是不是就很简单了呢？我们只需要拆分出每天需要多少流量，成交多少单，每天利润达到多少，只需要把每天的小目标完成，那么我们的大目标是不是就很容易达到了呢？
3.必备素质
第一点：必须狠狠执行，可能短期完不成一天的目标，但是我们可以通过努力，实现短期可以看到的效果。
第二点：时刻监督自己，可以把每天完成任务的进度写成日记或者写成分享发布到朋友圈，让朋友一起监督，这样动力会更强一些哦。
第三点：【目标倒推思维】可以运用到我们不同的目标上，如兴趣爱好，生活习惯养成等等，无非就是把目标拆解成每日任务。
看到这里是不是迫不及待给自己设定一个目标了呢？
⑤ 如何实现自己的目标
人生奋斗就是为了自己的目标，定这个目标，好高骛远的目标都是不切实际的，所以你要定的合理一些才能更容易完成。比如说你三年完成买房，如果你只有几千元的薪金，想买100万的房子，确实有点打击自己的意思。
⑥ 如何实现
给个例子啊？
[ZT]JAVA正则表达式
最近要对一些字符串处理，找了篇比较全的正则。
原文 http://wcjok.bokee.com/4293762.html
JAVA正则表达式
关键词： 正则表达式 ?
???????????????????????????????????????
正则表达式
作为本章的结尾，我们来看一看正则表达式(regular expression)。正则表达式是JDK 1.4的新功能，但是对sed和awk这样的Unix的标准实用工具，以及Python，Perl之类的语言来讲，它早就已经成为其不可或缺的组成部分了(有人甚至认为，它还是Perl能大获成功的最主要的原因)。单从技术角度来讲，正则表达式只是一种处理字符串的工具(过去Java这个任务是交由String，StringBuffer以及StringTokenizer处理的)，但是它常常和I/O一起使用，所以放到这里来讲也不算太离题吧。[66]
正则表达式是一种功能强大但又非常灵活的文本处理工具。它能让你用编程的方式来描述复杂的文本模式，然后在字符串里把它找出来。一旦你找到了这种模式，你就能随心所欲地处理这些文本了。虽然初看起来正则表达式的语法有点让人望而生畏，但它提供了一种精练的动态语言，使我们能用一种通用的方式来解决各种字符串 的问题，包括匹配，选择，编辑以及校验。
创建正则表达式
你可以从比较简单的东西入手学习正则表达式。要想全面地掌握怎样构建正则表达式，可以去看JDK文档的java.util.regex的Pattern类的文档。
字符
B 字符B
\xhh 16进制值0xhh所表示的字符
\uhhhh 16进制值0xhhhh所表示的Unicode字符
\t Tab
\n 换行符
\r 回车符
\f 换页符
\e Escape
正则表达式的强大体现在它能定义字符集(character class)。下面是一些最常见的字符集及其定义的方式，此外还有一些预定义的字符集：
字符集
. 表示任意一个字符
[abc] 表示字符a，b，c中的任意一个(与a|b|c相同)
[^abc] 除a，b，c之外的任意一个字符(否定)
[a-zA-Z] 从a到z或A到Z当中的任意一个字符(范围)
[abc[hij]] a,b,c,h,i,j中的任意一个字符(与a|b|c|h|i|j相同)(并集)
[a-z&&[hij]] h,i,j中的一个(交集)
\s 空格字符(空格键, tab, 换行, 换页, 回车)
\S 非空格字符([^\s])
\d 一个数字，也就是[0-9]
\D 一个非数字的字符，也就是[^0-9]
\w 一个单词字符(word character)，即[a-zA-Z_0-9]
\W 一个非单词的字符，[^\w]
如果你用过其它语言的正则表达式，那么你一眼就能看出反斜杠的与众不同。在其它语言里，"\\"的意思是"我只是要在正则表达式里插入一个反斜杠。没什么特别的意思。"但是在Java里，"\\"的意思是"我要插入一个正则表达式的反斜杠，所以跟在它后面的那个字符的意思就变了。"举例来说，如果你想表示一个或更多的"单词字符"，那么这个正则表达式就应该是"\\w+"。如果你要插入一个反斜杠，那就得用"\\\\"。不过像换行，跳格之类的还是只用一根反斜杠："\n\t"。
这里只给你讲一个例子；你应该JDK文档的java.util.regex.Pattern加到收藏夹里，这样就能很容易地找到各种正则表达式的模式了。
逻辑运算符
XY X 后面跟着 Y
X|Y X或Y
(X) 一个"要匹配的组(capturing group)". 以后可以用\i来表示第i个被匹配的组。
边界匹配符
^ 一行的开始
$ 一行的结尾
\b 一个单词的边界
\B 一个非单词的边界
\G 前一个匹配的结束
举一个具体一些的例子。下面这些正则表达式都是合法的，而且都能匹配"Rudolph"：
Rudolph[rR]udolph[rR][aeiou][a-z]ol.*R.*
数量表示符
"数量表示符(quantifier)"的作用是定义模式应该匹配多少个字符。
Greedy(贪婪的)： 除非另有表示，否则数量表示符都是greedy的。Greedy的表达式会一直匹配下去，直到匹配不下去为止。(如果你发现表达式匹配的结果与预期的不符)，很有可能是因为，你以为表达式会只匹配前面几个字符，而实际上它是greedy的，因此会一直匹配下去。
Reluctant(勉强的)： 用问号表示，它会匹配最少的字符。也称为lazy, minimal matching, non-greedy, 或ungreedy。
Possessive(占有的)： 目前只有Java支持(其它语言都不支持)。它更加先进，所以你可能还不太会用。用正则表达式匹配字符串的时候会产生很多中间状态，(一般的匹配引擎会保存这种中间状态，)这样匹配失败的时候就能原路返回了。占有型的表达式不保存这种中间状态，因此也就不会回头重来了。它能防止正则表达式的失控，同时也能提高运行的效率。
Greedy Reluctant Possessive 匹配
X? X?? X?+ 匹配一个或零个X
X* X*? X*+ 匹配零或多个X
X+ X+? X++ 匹配一个或多个X
X{n} X{n}? X{n}+ 匹配正好n个X
X{n,} X{n,}? X{n,}+ 匹配至少n个X
X{n,m} X{n,m}? X{n,m}+ 匹配至少n个，至多m个X
再提醒一下，要想让表达式照你的意思去运行，你应该用括号把'X'括起来。比方说：
abc+
似乎这个表达式能匹配一个或若干个'abc'，但是如果你真的用它去匹配'abcabcabc'的话，实际上只会找到三个字符。因为这个表达式的意思是'ab'后边跟着一个或多个'c'。要想匹配一个或多个完整的'abc'，你应该这样：
(abc)+
正则表达式能轻而易举地把你给耍了；这是一种建立在Java之上的新语言。
CharSequence
JDK 1.4定义了一个新的接口，叫CharSequence。它提供了String和StringBuffer这两个类的字符序列的抽象：
interface CharSequence { charAt(int i); length(); subSequence(int start, int end); toString();}
为了实现这个新的CharSequence接口，String，StringBuffer以及CharBuffer都作了修改。很多正则表达式的操作都要拿CharSequence作参数。
Pattern和Matcher
先给一个例子。下面这段程序可以测试正则表达式是否匹配字符串。第一个参数是要匹配的字符串，后面是正则表达式。正则表达式可以有多个。在Unix/Linux环境下，命令行下的正则表达式还必须用引号。
当你创建正则表达式时，可以用这个程序来判断它是不是会按照你的要求工作。
//: c12:TestRegularExpression.java// Allows you to easly try out regular expressions.// {Args: abcabcabcdefabc "abc+" "(abc)+" "(abc){2,}" }import java.util.regex.*;publicclass TestRegularExpression {publicstaticvoid main(String[] args) {if(args.length < 2) { System.out.println("Usage:\n" +"java TestRegularExpression " +"characterSequence regularExpression+"); System.exit(0); } System.out.println("Input: \"" + args[0] + "\"");for(int i = 1; i < args.length; i++) { System.out.println("Regular expression: \"" + args[i] + "\""); Pattern p = Pattern.compile(args[i]); Matcher m = p.matcher(args[0]);while(m.find()) { System.out.println("Match \"" + m.group() +"\" at positions " + m.start() + "-" + (m.end() - 1)); } } }} ///:~
Java的正则表达式是由java.util.regex的Pattern和Matcher类实现的。Pattern对象表示经编译的正则表达式。静态的compile( )方法负责将表示正则表达式的字符串编译成Pattern对象。正如上述例程所示的，只要给Pattern的matcher( )方法送一个字符串就能获取一个Matcher对象。此外，Pattern还有一个能快速判断能否在input里面找到regex的(注意，原文有误，漏了方法名)
staticboolean matches(?regex, ?input)
以及能返回String数组的split( )方法，它能用regex把字符串分割开来。
只要给Pattern.matcher( )方法传一个字符串就能获得Matcher对象了。接下来就能用Matcher的方法来查询匹配的结果了。
boolean matches()boolean lookingAt()boolean find()boolean find(int start)
matches( )的前提是Pattern匹配整个字符串，而lookingAt( )的意思是Pattern匹配字符串的开头。
find( )
Matcher.find( )的功能是发现CharSequence里的，与pattern相匹配的多个字符序列。例如：
//: c12:FindDemo.javaimport java.util.regex.*;import com.bruceeckel.simpletest.*;import java.util.*;publicclass FindDemo {privatestatic Test monitor = new Test();publicstaticvoid main(String[] args) { Matcher m = Pattern.compile("\\w+") .matcher("Evening is full of the linnet's wings");while(m.find()) System.out.println(m.group());int i = 0;while(m.find(i)) { System.out.print(m.group() + " "); i++; } monitor.expect(new String[] {"Evening","is","full","of","the","linnet","s","wings","Evening vening ening ning ing ng g is is s full " +"full ull ll l of of f the the he e linnet linnet " +"innet nnet net et t s s wings wings ings ngs gs s " }); }} ///:~
"\\w+"的意思是"一个或多个单词字符"，因此它会将字符串直接分解成单词。find( )像一个迭代器，从头到尾扫描一遍字符串。第二个find( )是带int参数的，正如你所看到的，它会告诉方法从哪里开始找——即从参数位置开始查找。
Groups
Group是指里用括号括起来的，能被后面的表达式调用的正则表达式。Group 0 表示整个表达式，group 1表示第一个被括起来的group，以此类推。所以；
A(B(C))D
里面有三个group：group 0是ABCD， group 1是BC，group 2是C。
你可以用下述Matcher方法来使用group：
public int groupCount( )返回matcher对象中的group的数目。不包括group0。
public String group( ) 返回上次匹配操作(比方说find( ))的group 0(整个匹配)
public String group(int i)返回上次匹配操作的某个group。如果匹配成功，但是没能找到group，则返回null。
public int start(int group)返回上次匹配所找到的，group的开始位置。
public int end(int group)返回上次匹配所找到的，group的结束位置，最后一个字符的下标加一。
下面我们举一些group的例子：
//: c12:Groups.javaimport java.util.regex.*;import com.bruceeckel.simpletest.*;publicclass Groups {privatestatic Test monitor = new Test();staticpublicfinal String poem ="Twas brillig, and the slithy toves\n" +"Did gyre and gimble in the wabe.\n" +"All mimsy were the borogoves,\n" +"And the mome raths outgrabe.\n\n" +"Beware the Jabberwock, my son,\n" +"The jaws that bite, the claws that catch.\n" +"Beware the Jubjub bird, and shun\n" +"The frumious Bandersnatch.";publicstaticvoid main(String[] args) { Matcher m = Pattern.compile("(?m)(\\S+)\\s+((\\S+)\\s+(\\S+))$") .matcher(poem);while(m.find()) {for(int j = 0; j <= m.groupCount(); j++) System.out.print("[" + m.group(j) + "]"); System.out.println(); } monitor.expect(new String[]{"[the slithy toves]" +"[the][slithy toves][slithy][toves]","[in the wabe.][in][the wabe.][the][wabe.]","[were the borogoves,]" +"[were][the borogoves,][the][borogoves,]","[mome raths outgrabe.]" +"[mome][raths outgrabe.][raths][outgrabe.]","[Jabberwock, my son,]" +"[Jabberwock,][my son,][my][son,]","[claws that catch.]" +"[claws][that catch.][that][catch.]","[bird, and shun][bird,][and shun][and][shun]","[The frumious Bandersnatch.][The]" +"[frumious Bandersnatch.][frumious][Bandersnatch.]" }); }} ///:~
这首诗是Through the Looking Glass的，Lewis Carroll的"Jabberwocky"的第一部分。可以看到这个正则表达式里有很多用括号括起来的group，它是由任意多个连续的非空字符('\S+')和任意多个连续的空格字符('\s+')所组成的，其最终目的是要捕获每行的最后三个单词；'$'表示一行的结尾。但是'$'通常表示整个字符串的结尾，所以这里要明确地告诉正则表达式注意换行符。这一点是由'(?m)'标志完成的(模式标志会过一会讲解)。
start( )和end( )
如果匹配成功，start( )会返回此次匹配的开始位置，end( )会返回此次匹配的结束位置，即最后一个字符的下标加一。如果之前的匹配不成功(或者没匹配)，那么无论是调用start( )还是end( )，都会引发一个IllegalStateException。下面这段程序还演示了matches( )和lookingAt( )：
//: c12:StartEnd.javaimport java.util.regex.*;import com.bruceeckel.simpletest.*;publicclass StartEnd {privatestatic Test monitor = new Test();publicstaticvoid main(String[] args) { String[] input = new String[] {"Java has regular expressions in 1.4","regular expressions now expressing in Java","Java represses oracular expressions" }; Pattern p1 = Pattern.compile("re\\w*"), p2 = Pattern.compile("Java.*");for(int i = 0; i < input.length; i++) { System.out.println("input " + i + ": " + input[i]); Matcher m1 = p1.matcher(input[i]), m2 = p2.matcher(input[i]);while(m1.find()) System.out.println("m1.find() '" + m1.group() +"' start = "+ m1.start() + " end = " + m1.end());while(m2.find()) System.out.println("m2.find() '" + m2.group() +"' start = "+ m2.start() + " end = " + m2.end());if(m1.lookingAt()) // No reset() necessary System.out.println("m1.lookingAt() start = " + m1.start() + " end = " + m1.end());if(m2.lookingAt()) System.out.println("m2.lookingAt() start = " + m2.start() + " end = " + m2.end());if(m1.matches()) // No reset() necessary System.out.println("m1.matches() start = " + m1.start() + " end = " + m1.end());if(m2.matches()) System.out.println("m2.matches() start = " + m2.start() + " end = " + m2.end()); } monitor.expect(new String[] {"input 0: Java has regular expressions in 1.4","m1.find() 'regular' start = 9 end = 16","m1.find() 'ressions' start = 20 end = 28","m2.find() 'Java has regular expressions in 1.4'" +" start = 0 end = 35","m2.lookingAt() start = 0 end = 35","m2.matches() start = 0 end = 35","input 1: regular expressions now " +"expressing in Java","m1.find() 'regular' start = 0 end = 7","m1.find() 'ressions' start = 11 end = 19","m1.find() 'ressing' start = 27 end = 34","m2.find() 'Java' start = 38 end = 42","m1.lookingAt() start = 0 end = 7","input 2: Java represses oracular expressions","m1.find() 'represses' start = 5 end = 14","m1.find() 'ressions' start = 27 end = 35","m2.find() 'Java represses oracular expressions' " +"start = 0 end = 35","m2.lookingAt() start = 0 end = 35","m2.matches() start = 0 end = 35" }); }} ///:~
⑦ 怎样实现
如果你原来的数据是日期格式的话，可以用年月日函数
A1=year（那个日期或者存放该日期的单元格）
B1=month（那个日期或者存放该日期的单元格）
C1=day（那个日期或者存放该日期的单元格）
⑧ 是怎么实现的
#include<reg51.h>
#include<intrins.h>
void delay(unsigned int x);
void main(void)
{ unsigned char x,i;
while(1) //死循环,让程序一直在运行
{
x=0x01; //设置一个变量 先等于1
for(i=0;i<8;i++) //循环八次
{
P1=x; //将X的值送P1口.
x=x<<1; //将X的值左移一位,效果:让下一个灯亮
delay(1000); //延时一定时间
} //结束本次循环,准备下次循环.
}
}
void delay(unsigned int x) //延时子程序,用于调用产生延时效果
{
int i;
for(i=0;i<x;i++)
{
_nop_();}
} 这是一个单片机二极管显示的程序