关于bbwjava的信息

本篇文章给大家谈谈bbwjava，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、急！Java 题库维护系统课程报告
• 2、在纯java应用中如何使用c3po？（ 没有框架，没有tomcat）
• 3、Java 第三方公钥 RSA加密求助
• 4、黑莓z10怎么清除BBW或者其他程序的缓存文件
• 5、落寞的王者，现在还好吗——黑莓9900

急！Java 题库维护系统课程报告

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.Scanner;

public class Main {

public static final String DATE_FORMAT = "MM月dd日";

private static final Scanner scanner = new Scanner(System.in);

public static ListItem itemList = null;

private static final String itemPath = "d:/item.txt";

public static int total;

private static int current=1;

public static void main(String[] args) {

try {

process();

} catch (IOException e) {

e.printStackTrace();

}

}

private static void init() throws IOException {

itemList = ItemReaderWriter.readItemsFromFile(itemPath);

total = itemList.size();

}

private static void process() throws IOException {

show();

String c = getInput();

while (!c.equals("a")  !c.equals("i")  !c.equals("d")  !c.equals("l")) {

System.err.println("输入错误！请输入a/i/d/l");

process();

}

if ("a".equals(c)) {

aOperation();

}

else if ("i".equals(c)) {

iOperation();

}

else if ("d".equals(c)) {

dOperation();

}

else if ("l".equals(c)) {

lOperation();

}

}

private static void print(String... msg) {

if (msg != null  msg.length  0) {

System.out.println(msg[0]);

}

else {

System.out.println();

}

}

private static String getDateNow() {

SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);

return sdf.format(new Date());

}

private static void show() {

print("/********************************************************/");

String dateStr = getDateNow();

print("题库维护系统   今天"+dateStr+"..........");

print("请选择相关操作:");

print("1.添加题目  按键盘字符(a)");

print("2.导入题目  按键盘字符(i)");

print("3.删除题目  按键盘字符(d)");

print("4.显示题目  按键盘字符(l)");

print("/********************************************************/");

}

private static void aOperation() throws IOException {

init();

print("***********************************************************");

print("添加题目,题库已有试题"+total+"条,当前录入第"+current+"条");

print("***********************************************************");

print("请输入题目:");

String title = (total+1) + "." + getInput();

print("请输入选项A:");

String a = "A." + getInput();

print("请输入选项B:");

String b = "B." + getInput();

print("请输入选项C:");

String c = "C." + getInput();

print("请输入选项D:");

String d = "D." + getInput();

Item item = new Item(title,a,b,c,d);

System.out.println(item);

ItemReaderWriter.writeToFile(item, itemPath);

total += 1;

current += 1;

print("输入成功,否继续输入?(y/n)");

String s = getInput();

if ("y".equals(s)) {

aOperation();

}

else {

process();

}

}

private static void iOperation() throws IOException{

init();

print("请输入需要导入题库文件路径:");

String path = getInput();

File f = new File(path);

if (!f.exists()) {

throw new IOException("不是一个有效的路径！");

}

else {

try {

ItemReaderWriter.importToFile(itemPath,path, total);

print("题库导入成功！");

} catch (Exception e) {

System.err.println("题库导入失败！" + e.getMessage());

e.printStackTrace();

}

}

process();

}

private static void dOperation() throws IOException {

init();

print("***********************************************************");

print("删除题目");

print("***********************************************************");

print("请输入所需删除题号：");

String numStr = getInput();

int num = 0;

try {

num = Integer.valueOf(numStr);

ItemReaderWriter.deleteByNum(itemPath,num);

print("删除试题成功！");

} catch (NumberFormatException e) {

System.err.println("输入的不是有效的题号！");

e.printStackTrace();

} catch (IOException ee) {

System.out.println("删除题目失败！" + ee);

ee.printStackTrace();

}

process();

}

private static void lOperation() throws IOException {

init();

print("***********************************************************");

if (itemList == null || itemList.size() == 0) {

print("目前题库中没有题目！");

return;

}

print("目前题库中共有" + itemList.size() + "道试题！");

for (int i=0;iitemList.size();i++) {

Item item = itemList.get(i);

print(item.getTitle());

print(item.getA());

print(item.getB());

print(item.getC());

print(item.getD());

print();

}

print("***********************************************************");

process();

}

private static String getInput() {

String cstr = scanner.next();

while (cstr == null || cstr.trim().length() == 0) {

print("请输入内容！");

cstr = scanner.next();

}

return cstr;

}

}

final class ItemReaderWriter {

// 假定题目的格式如下：

// 题目表述：

// 选项A：

// 选项B：

// 选项C：

// 选项D：

// 1道题有5行组成

public static ListItem readItemsFromFile(String filePath) throws IOException {

File f = new File(filePath);

if (!f.exists()) {

f.createNewFile();

}

ListItem itemList = new ArrayListItem();

BufferedReader br = new BufferedReader(new FileReader(filePath));

String line = null;

while ((line = br.readLine()) != null) {

// 标题

String title = line;

// 选项A

String a = line = br.readLine();

// 选项B

String b = line = br.readLine();

// 选项C

String c = line = br.readLine();

// 选项D

String d = line = br.readLine();

Item item = new Item(title,a,b,c,d);

itemList.add(item);

// 空行，每题之间空一行

line = br.readLine();

}

return itemList;

}

public static synchronized void writeToFile(Item item,String filePath) throws IOException {

FileWriter fw = new FileWriter(filePath,true);

if (Main.itemList != null  Main.itemList.size() = 0) {

// 空行，题目之间空一行

fw.write("\n\n");

}

// 标题

fw.write(item.getTitle());

fw.write("\n");

// 选项A

fw.write(item.getA());

fw.write("\n");

// 选项B

fw.write(item.getB());

fw.write("\n");

// 选项C

fw.write(item.getC());

fw.write("\n");

// 选项D

fw.write(item.getD());

fw.close();

}

public static void importToFile(String itemPath,String filePath,int total) throws IOException {

BufferedReader br = new BufferedReader(new FileReader(new File(filePath)));

String line = null;

while ((line = br.readLine()) != null) {

// 标题

String title = line;

if (title.matches("^\\d+.*$")) {

title = title.replaceFirst("\\d+", "");

title = (++total) + title;

}

// 选项A

String a = line = br.readLine();

// 选项B

String b = line = br.readLine();

// 选项C

String c = line = br.readLine();

// 选项D

String d = line = br.readLine();

Item item = new Item(title,a,b,c,d);

writeToFile(item, itemPath);

// 读取下一个空行

line = br.readLine();

}

br.close();

}

public static synchronized void deleteByNum(String filePath,int num) throws IOException {

ListItem itemList = readItemsFromFile(filePath);

boolean find = false;

if (itemList != null  itemList.size()  0) {

for (Item item : itemList) {

if (item.getTitle().startsWith(Integer.toString(num))) {

find = true;

itemList.remove(item);

break;

}

}

}

else {

System.out.println("题库中没有试题");

}

if (find) {

BufferedWriter bw = new BufferedWriter(new FileWriter(new File(filePath)));

for (int i=0;iitemList.size();i++) {

Item item = itemList.get(i);

// 标题

String title = item.getTitle();

title = title.replaceFirst("\\d+", "");

title = (i+1) + title;

bw.write(title);

bw.write("\n");

// 选项A

bw.write(item.getA());

bw.write("\n");

// 选项B

bw.write(item.getB());

bw.write("\n");

// 选项C

bw.write(item.getC());

bw.write("\n");

// 选项D

bw.write(item.getD());

if (i != itemList.size() - 1) {

bw.write("\n\n");

}

}

bw.close();

}

}

}

class Item {

private String title;

private String a;

private String b;

private String c;

private String d;

public Item() {

}

public Item(String title,String a,String b,String c,String d) {

this.title = title;

this.a = a;

this.b = b;

this.c = c;

this.d = d;

}

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

public String getA() {

return a;

}

public void setA(String a) {

this.a = a;

}

public String getB() {

return b;

}

public void setB(String b) {

this.b = b;

}

public String getC() {

return c;

}

public void setC(String c) {

this.c = c;

}

public String getD() {

return d;

}

public void setD(String d) {

this.d = d;

}

@Override

public String toString() {

return "Item [title=" + title + ", a=" + a + ", b=" + b + ", c=" + c

+ ", d=" + d + "]";

}

}

在纯java应用中如何使用c3po？（ 没有框架，没有tomcat）

定时问题 ORACLE 有作业来实现的不用写到项目里，如果非要用java 还不用框架来弄的话可以考虑下

在xml中配置监听

listener-classcom.timer.MyListener/listener-class

/listener

listener

listener-classcom.IMS.ImsListener/listener-class

/listener

import java.util.Timer;

import javax.servlet.ServletContextEvent;

import javax.servlet.ServletContextListener;

public class MyListener implements ServletContextListener {

private Timer timer = null;

public void contextInitialized(ServletContextEvent event) {

timer = new Timer(true);

//调用执行类设置任务计划，启动和间隔时间

timer.schedule(new MyTask(), 10000, 30000);

}

public void contextDestroyed(ServletContextEvent event) {

timer.cancel();

}

}

//执行类

import java.util.TimerTask;

public class MyTask extends TimerTask {

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("1113");

}

}

package com.timer;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Random;

import java.util.TimerTask;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import com.olive.sebb.wlbqz.domain.SebbWlbqz;

import com.olive.sebb.wlbqz.service.WlbqzService;

import com.olive.sebb.wlbqz.service.WlbqzServiceImpl;

import com.opensymphony.webwork.ServletActionContext;

//执行定时任务

public class MyTask extends TimerTask {

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("1113");

}

}

Java 第三方公钥 RSA加密求助

下面是RSA加密代码。

/**

* RSA算法，实现数据的加密解密。

* @author ShaoJiang

*

*/

public class RSAUtil {

private static Cipher cipher;

static{

try {

cipher = Cipher.getInstance("RSA");

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

} catch (NoSuchPaddingException e) {

e.printStackTrace();

}

}

/**

* 生成密钥对

* @param filePath 生成密钥的路径

* @return

*/

public static MapString,String generateKeyPair(String filePath){

try {

KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");

// 密钥位数

keyPairGen.initialize(1024);

// 密钥对

KeyPair keyPair = keyPairGen.generateKeyPair();

// 公钥

PublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

// 私钥

PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

//得到公钥字符串

String publicKeyString = getKeyString(publicKey);

//得到私钥字符串

String privateKeyString = getKeyString(privateKey);

FileWriter pubfw = new FileWriter(filePath+"/publicKey.keystore");

FileWriter prifw = new FileWriter(filePath+"/privateKey.keystore");

BufferedWriter pubbw = new BufferedWriter(pubfw);

BufferedWriter pribw = new BufferedWriter(prifw);

pubbw.write(publicKeyString);

pribw.write(privateKeyString);

pubbw.flush();

pubbw.close();

pubfw.close();

pribw.flush();

pribw.close();

prifw.close();

//将生成的密钥对返回

MapString,String map = new HashMapString,String();

map.put("publicKey",publicKeyString);

map.put("privateKey",privateKeyString);

return map;

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

* 得到公钥

*

* @param key

* 密钥字符串（经过base64编码）

* @throws Exception

*/

public static PublicKey getPublicKey(String key) throws Exception {

byte[] keyBytes;

keyBytes = (new BASE64Decoder()).decodeBuffer(key);

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

PublicKey publicKey = keyFactory.generatePublic(keySpec);

return publicKey;

}

/**

* 得到私钥

*

* @param key

* 密钥字符串（经过base64编码）

* @throws Exception

*/

public static PrivateKey getPrivateKey(String key) throws Exception {

byte[] keyBytes;

keyBytes = (new BASE64Decoder()).decodeBuffer(key);

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

return privateKey;

}

/**

* 得到密钥字符串（经过base64编码）

*

* @return

*/

public static String getKeyString(Key key) throws Exception {

byte[] keyBytes = key.getEncoded();

String s = (new BASE64Encoder()).encode(keyBytes);

return s;

}

/**

* 使用公钥对明文进行加密，返回BASE64编码的字符串

* @param publicKey

* @param plainText

* @return

*/

public static String encrypt(PublicKey publicKey,String plainText){

try {

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

byte[] enBytes = cipher.doFinal(plainText.getBytes());

return (new BASE64Encoder()).encode(enBytes);

} catch (InvalidKeyException e) {

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

e.printStackTrace();

} catch (BadPaddingException e) {

e.printStackTrace();

}

return null;

}

/**

* 使用keystore对明文进行加密

* @param publicKeystore 公钥文件路径

* @param plainText 明文

* @return

*/

public static String encrypt(String publicKeystore,String plainText){

try {

FileReader fr = new FileReader(publicKeystore);

BufferedReader br = new BufferedReader(fr);

String publicKeyString="";

String str;

while((str=br.readLine())!=null){

publicKeyString+=str;

}

br.close();

fr.close();

cipher.init(Cipher.ENCRYPT_MODE,getPublicKey(publicKeyString));

byte[] enBytes = cipher.doFinal(plainText.getBytes());

return (new BASE64Encoder()).encode(enBytes);

} catch (InvalidKeyException e) {

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

e.printStackTrace();

} catch (BadPaddingException e) {

e.printStackTrace();

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

* 使用私钥对明文密文进行解密

* @param privateKey

* @param enStr

* @return

*/

public static String decrypt(PrivateKey privateKey,String enStr){

try {

cipher.init(Cipher.DECRYPT_MODE, privateKey);

byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));

return new String(deBytes);

} catch (InvalidKeyException e) {

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

e.printStackTrace();

} catch (BadPaddingException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

return null;

}

/**

* 使用keystore对密文进行解密

* @param privateKeystore 私钥路径

* @param enStr 密文

* @return

*/

public static String decrypt(String privateKeystore,String enStr){

try {

FileReader fr = new FileReader(privateKeystore);

BufferedReader br = new BufferedReader(fr);

String privateKeyString="";

String str;

while((str=br.readLine())!=null){

privateKeyString+=str;

}

br.close();

fr.close();

cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKeyString));

byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));

return new String(deBytes);

} catch (InvalidKeyException e) {

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

e.printStackTrace();

} catch (BadPaddingException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

}

黑莓z10怎么清除BBW或者其他程序的缓存文件

安装rom,到目录里找JAVA文件夹--- F3搜索BBW 和你要删除的软件名 ----删除掉~~~连电脑刷机~~~

落寞的王者，现在还好吗——黑莓9900

当我站在高中校门口时，目光总会被悬挂着的巨大海报吸引。

那时候，海报上展示过很多东西，

像刚刚加入运营商合约机的小米2和iPhone4，

或者是很丑、却莫名吸引人的大彩块、Windows phone的代表机型Lumia，

当然少不了的，是采用方屏加全键盘设计的诺基亚E系列。

倒也好笑，我是先了解诺基亚的全键盘，再看新闻知道黑莓的。

商务派的硬朗外观，绝佳的隐私保护，在那个安卓还丑爆的时间里，对黑莓莫名产生一股好感。

那时的我，下定决心，高考考完，买部黑莓或者Lumia。

是的，当时我是这么想的。

然后高考结束，我跑去手机店，买了部小米3……

而我拥有Lumia的梦想，已经在体验过Lumia1020和930后，消失殆尽；

而黑莓，在迟到了九年后，我终于入手了一部黑莓的代表作——黑莓9900。

买它的时候，我还特地选了全套包装。

无他，就是为了全套包装中黑莓送的那个皮套。

从皮套中拿出手机，自动亮屏，放进去，自动息屏，

哈哈，骚的一批。

由于是海外版，包装盒都是已经被拆过的，只是里面的配件还是很齐全。

欧标的插头，皮套，耳机，一大堆不用读……

还有可拆卸电池，这种感觉距离自己很遥远的东西。

不得不说，那个时候的手机，包装看起来不怎么样，送的东西还真不少。

现在的手机，包装盒一个比一个花里胡哨，里面耳机都没有了。

全键盘时代的美感！

这手机，真就是商务风，男人味。

金属色泽的边框，配上后盖凯夫拉条纹的装饰，

加上后背大倒角的设计，

比起现在手机在颜色上做文章，9900在造型上可以说，简约而不简单。

正面是的两个元素，都是特立独行。

640*480的屏幕 ，显示效果仍然不错，颗粒感没有我想象中那么严重；

配合上 黑莓标志性的全键盘 ，

我的大脑立刻想到看过的21世纪初的美剧和电影，

在高楼林立的纽约市中心，熟练地掏出黑莓，飞快地回着好几千万合同的邮件。

从现在的观点来看，黑莓的造型，确实是落后了，

但它外形具备的商务属性，不由自主地将人拉回21世纪初期的狂热年代中。

系统，BBOS 7

为什么买9900，因为它是BBOS 7。

一个当初很“智能”，现在却很“功能”的系统。

回想起2011，iOS已经发展到了iOS5，在基本功能完善的差不多的时候，开始引入Siri；

安卓已经发布到安卓4.0，此时的安卓除了流畅性上不如iOS，功能上已经并驾齐驱。

而Windows phone还停留在7，没有下拉通知栏，没有音量分离功能。

BBOS 7比Windows phone要成熟的多。它的系统操作逻辑，是和全触屏的安卓、iOS远远不同的。

BBOS 7，基于黑莓标志性元素，全键盘，来进行设计。

使用9900的中间的选择按钮，上下左右滑动，可以实现类似9000轨迹球的操作。

滑动选择，按下选中，在次级菜单中重复相同操作，

一个简单的类轨迹球按钮，让BBOS 7轻松实现单手操作，

配合9900轻便的体型，

单手就能掌控的感觉，在这个手机越来越大，越来越重的时代里，简直就是Heaven。

2020年现在，使用9900，一个不得不面临的问题，就是软件的缺乏。

之前在网上查过相关信息，大家都说BBOS 7的blackberry world（BBW）已经关闭，没有办法使用。

但实际上还是可以进去，下载相关应用的。

但前提是，得有应用啊！

在BBW和论坛逛了许久，

微信、支付宝是肯定没有了，

QQ倒是意外的可以使用，虽然经常网络不稳定；

微博可以使用，同样偶尔刷新不出来，勉强可用；

浏览器除了自带的之外，UC和QQ、opera都是很久之前，使用功能机的状态。

如果你怀念java时代的浏览器，倒是可以一试，我反正使用自带浏览器。

时间同步需要下载专门的应用，否则经常出现时间不准而不能用浏览器的状况。

相机和我手上的魅族相比，对焦都是模糊的，毕竟是九年前的机器。

总的来说，9900，已经不属于现在这个时代智能机的定义范围，

它，就是应用比Java多一点的，功能机。

为什么我会现在，入手一部9900？

之前的我，很不理解“逆潮流”的那帮人，不使用社交媒体，不使用智能机，用功能机，只用电话和短信，比如汪涵~

在经历狂热的玩机之后，我也慢慢的，开始对智能手机对我的影响进行反思。

首先，是人，而不是设备，有主观能动。

设备是为使用者服务，任何排斥设备带来的便利而想“返璞归真”的想法，都是使用者理想化的“自欺欺人”。

我排斥的，不是设备，是信息爆炸。

我没有办法结束智能设备带给我的信息爆炸。

而在爆炸的信息里筛选自己的信息，越来越困难。

这些信息，影响我的思考，干扰我的行为。

这不是设备带来的，

这是由于设备具有便利性，大量信息有着更快速的途径来被我接触。

是越来越多垃圾信息通过设备来干扰我，

这，让我很苦恼。

使用两部手机，一部接受主力卡中的必要信息，如短信和电话；

另一部则是智能机，方便日常生活。

我之前很不了解双击党，直到这次疫情期间，大量信息的摄入让我有了“信息恐惧”。

9900，不是属于这个时代的机器，

没有黑莓的服务提供，它，就是一部功能机。

但是， 它有独特的外形，独特的系统，独特的附加属性 ，

我愿意，将我远离信息爆炸的生活，交给它。

当我打开远古版本的qq和浏览器，

我又想到我高中时，对于新奇的数码设备的满怀好奇，

我没有想过，那个时候我需要新设备满足自己的好奇，

现在，需要旧设备来实现自己的平衡。

如果你需要一部功能机，9900值得买，

做工、外形，以及重要的全键盘。

如果是好奇，那就不必购买，相信我，完全不符合现在触屏手机操作的BBOS 7，有着很高的学习成本。

最后再放一张9900的美照，怀念一下九年前那个百花齐放的手机市场，和现在千篇一律迥然不同、“百家争鸣”、人心潮澎湃的手机市场。

关于bbwjava和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。