To create a Java application that uses the Twitter API to stream tweets containing specific keywords in real-time, you'll need to follow these steps:

1. Set up a Twitter Developer Account and create an App
2. Get your API keys and access tokens
3. Add required dependencies (libraries) to your project
4. Implement the code for streaming tweets and storing them in SQLite database
5. Create a simple interface for users to view and filter stored tweets

Here's a step-by-step guide on how to do this:

### Step 1: Set up a Twitter Developer Account and create an App

1. Go to https://developer.twitter.com/ and sign in with your Twitter account.
2. Apply for a developer account if you don't have one already.
3. Once approved, go to the Dashboard and click "Create an app".
4. Fill out the required information and submit the form.

### Step 2: Get your API keys and access tokens

After creating your app, go to the "Keys and Tokens" tab and note down the following details:

- API Key
- API Secret Key
- Access Token
- Access Token Secret

You will use these credentials in your Java application to authenticate with the Twitter API.

### Step 3: Add required dependencies (libraries) to your project

Add the following libraries to your project using Maven or Gradle:

1. Twitter4J - A library to interact with the Twitter API
2. SQLite JDBC Driver - A library to connect and work with SQLite databases

For Maven, add the following dependencies to your `pom.xml` file:

```xml
<dependencies>
    <dependency>
        <groupId>org.twitter4j</groupId>
        <artifactId>twitter4j-stream</artifactId>
        <version>4.0.7</version>
    </dependency>
    <dependency>
        <groupId>org.xerial</groupId>
        <artifactId>sqlite-jdbc</artifactId>
        <version>3.34.0</version>
    </dependency>
</dependencies>
```

For Gradle, add the following dependencies to your `build.gradle` file:

```groovy
dependencies {
    implementation 'org.twitter4j:twitter4j-stream:4.0.7'
    implementation 'org.xerial:sqlite-jdbc:3.34.0'
}
```

### Step 4: Implement the code for streaming tweets and storing them in SQLite database

Create a new Java class called `TwitterStreamApp` with the following content:

```java
import twitter4j.*;
import twitter4j.conf.ConfigurationBuilder;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class TwitterStreamApp {

    private static final String DB_URL = "jdbc:sqlite:tweets.db";

    public static void main(String[] args) throws SQLException {
        // Set up the Twitter API credentials
        ConfigurationBuilder cb = new ConfigurationBuilder();
        cb.setDebugEnabled(true)
                .setOAuthConsumerKey("YOUR_API_KEY")
                .setOAuthConsumerSecret("YOUR_API_SECRET_KEY")
                .setOAuthAccessToken("YOUR_ACCESS_TOKEN")
                .setOAuthAccessTokenSecret("YOUR_ACCESS_TOKEN_SECRET");

        // Initialize the Twitter Stream
        TwitterStreamFactory factory = new TwitterStreamFactory(cb.build());
        TwitterStream twitterStream = factory.getInstance();

        // Set up the listener for incoming tweets
        StatusListener listener = new StatusAdapter() {
            @Override
            public void onStatus(Status status) {
                System.out.println(status.getUser().getScreenName() + ": " + status.getText());

                try (Connection connection = DriverManager.getConnection(DB_URL)) {
                    String sql = "INSERT INTO tweets(username, text) VALUES (?, ?)";
                    PreparedStatement pstmt = connection.prepareStatement(sql);
                    pstmt.setString(1, status.getUser().getScreenName());
                    pstmt.setString(2, status.getText());
                    pstmt.executeUpdate();
                } catch (SQLException e) {
                    System.err.println(e.getMessage());
                }
            }

            @Override
            public void onException(Exception ex) {
                ex.printStackTrace();
            }
        };

        // Start streaming tweets with specific keywords
        twitterStream.addListener(listener);
        FilterQuery query = new FilterQuery();
        query.track("keyword1", "keyword2"); // Replace with your desired keywords
        twitterStream.filter(query);
    }
}
```

Replace the placeholders `YOUR_API_KEY`, `YOUR_API_SECRET_KEY`, `YOUR_ACCESS_TOKEN`, and `YOUR_ACCESS_TOKEN_SECRET` with your actual Twitter API credentials.

### Step 5: Create a simple interface for users to view and filter stored tweets

You can create a simple command-line interface or a GUI-based application to let users view and filter the stored tweets. For this example, we'll use a basic command-line interface:

Create a new Java class called `TweetViewer` with the following content:

```java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;

public class TweetViewer {

    private static final String DB_URL = "jdbc:sqlite:tweets.db";

    public static void main(String[] args) throws SQLException {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("\nEnter a keyword to search for tweets or type 'exit' to quit:");
            String input = scanner.nextLine();

            if ("exit".equalsIgnoreCase(input)) {
                break;
            }

            try (Connection connection = DriverManager.getConnection(DB_URL)) {
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT * FROM tweets WHERE text LIKE '%" + input + "%'");

                System.out.println("\nTweets containing '" + input + "':");
                while (rs.next()) {
                    System.out.println(rs.getString("username") + ": " + rs.getString("text"));
                }
            } catch (SQLException e) {
                System.err.println(e.getMessage());
            }
        }

        scanner.close();
    }
}
```

Now, run the `TwitterStreamApp` to start streaming and storing tweets in real-time. In a separate terminal or command prompt, run the `TweetViewer` class to view and filter stored tweets.

Please note that this example is for educational purposes only and should not be used as-is in production environments. You may need to handle exceptions, improve security, and optimize performance according to your specific requirements.
트위터 API를 사용하여 특정 키워드가 포함된 트윗을 실시간으로 스트리밍하는 Java 애플리케이션을 만들려면 다음 단계를 따라야 합니다.

1. 트위터 개발자 계정을 설정하고 앱을 만듭니다
2. API 키와 액세스 토큰을 받습니다
3. 프로젝트에 필요한 종속성(라이브러리)을 추가합니다
4. 트윗을 스트리밍하고 SQLite 데이터베이스에 저장하는 코드를 구현합니다
5. 사용자가 저장된 트윗을 보고 필터링할 수 있는 간단한 인터페이스 만들기

이 작업을 수행하는 방법에 대한 단계별 가이드는 다음과 같습니다.

### 1단계: 트위터 개발자 계정 설정 및 앱 만들기

1. https://developer.twitter.com/ 로 이동하여 트위터 계정으로 로그인합니다.
2. 아직 개발자 계정이 없는 경우 개발자 계정을 신청합니다.
3. 승인되면 대시보드로 이동하여 "앱 만들기"를 클릭합니다.
4. 필수 정보를 입력하고 양식을 제출합니다.

### 2단계: API 키 및 액세스 토큰 받기

앱을 만든 후 "Keys and Tokens" 탭으로 이동하여 다음 세부 정보를 메모합니다:

- API Key
- API Secret Key
- Access Token
- Access Token Secret

Java 애플리케이션에서 이 자격 증명을 사용하여 트위터 API를 인증합니다.

### 3단계: 프로젝트에 필수 종속성(라이브러리) 추가

Maven 또는 Gradle을 사용하여 프로젝트에 다음 라이브러리를 추가합니다.

1. Twitter4J - 트위터 API와 상호 작용하기 위한 라이브러리
2. SQLite JDBC 드라이버 - SQLite 데이터베이스에 연결하고 작업하기 위한 라이브러리

Maven의 경우, `pom.xml` 파일에 다음 종속성을 추가합니다:

```xml
<dependencies>
    <dependency>
        <groupId>org.twitter4j</groupId>
        <artifactId>twitter4j-stream</artifactId>
        <version>4.0.7</version>
    </dependency>
    <dependency>
        <groupId>org.xerial</groupId>
        <artifactId>sqlite-jdbc</artifactId>
        <version>3.34.0</version>
    </dependency>
</dependencies>
```

Gradle의 경우, `build.gradle` 파일에 다음 종속성을 추가합니다:

```groovy
dependencies {
    implementation 'org.twitter4j:twitter4j-stream:4.0.7'
    implementation 'org.xerial:sqlite-jdbc:3.34.0'
}
```

### 4단계: 트윗을 스트리밍하고 SQLite 데이터베이스에 저장하는 코드 구현

다음 내용으로 `TwitterStreamApp`이라는 Java 클래스를 새로 생성합니다:

```java
import twitter4j.*;
import twitter4j.conf.ConfigurationBuilder;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class TwitterStreamApp {

    private static final String DB_URL = "jdbc:sqlite:tweets.db";

    public static void main(String[] args) throws SQLException {
        // Set up the Twitter API credentials
        ConfigurationBuilder cb = new ConfigurationBuilder();
        cb.setDebugEnabled(true)
                .setOAuthConsumerKey("YOUR_API_KEY")
                .setOAuthConsumerSecret("YOUR_API_SECRET_KEY")
                .setOAuthAccessToken("YOUR_ACCESS_TOKEN")
                .setOAuthAccessTokenSecret("YOUR_ACCESS_TOKEN_SECRET");

        // Initialize the Twitter Stream
        TwitterStreamFactory factory = new TwitterStreamFactory(cb.build());
        TwitterStream twitterStream = factory.getInstance();

        // Set up the listener for incoming tweets
        StatusListener listener = new StatusAdapter() {
            @Override
            public void onStatus(Status status) {
                System.out.println(status.getUser().getScreenName() + ": " + status.getText());

                try (Connection connection = DriverManager.getConnection(DB_URL)) {
                    String sql = "INSERT INTO tweets(username, text) VALUES (?, ?)";
                    PreparedStatement pstmt = connection.prepareStatement(sql);
                    pstmt.setString(1, status.getUser().getScreenName());
                    pstmt.setString(2, status.getText());
                    pstmt.executeUpdate();
                } catch (SQLException e) {
                    System.err.println(e.getMessage());
                }
            }

            @Override
            public void onException(Exception ex) {
                ex.printStackTrace();
            }
        };

        // Start streaming tweets with specific keywords
        twitterStream.addListener(listener);
        FilterQuery query = new FilterQuery();
        query.track("keyword1", "keyword2"); // Replace with your desired keywords
        twitterStream.filter(query);
    }
}
```

플레이스홀더 `YOUR_API_KEY`, `YOUR_API_SECRET_KEY`, `YOUR_ACCESS_TOKEN` 및 `YOUR_ACCESS_TOKEN_SECRET`을 실제 트위터 API 자격 증명으로 바꿉니다.

### 5단계: 사용자가 저장된 트윗을 보고 필터링할 수 있는 간단한 인터페이스 만들기

단순 명령줄 인터페이스 또는 GUI 기반 애플리케이션을 만들어 사용자가 저장된 트윗을 보고 필터링할 수 있도록 할 수 있습니다. 이 예제에서는 기본 명령줄 인터페이스를 사용합니다.

다음 내용을 포함하는 `TweetViewer`라는 Java 클래스를 새로 만듭니다:

```java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;

public class TweetViewer {

    private static final String DB_URL = "jdbc:sqlite:tweets.db";

    public static void main(String[] args) throws SQLException {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("\nEnter a keyword to search for tweets or type 'exit' to quit:");
            String input = scanner.nextLine();

            if ("exit".equalsIgnoreCase(input)) {
                break;
            }

            try (Connection connection = DriverManager.getConnection(DB_URL)) {
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT * FROM tweets WHERE text LIKE '%" + input + "%'");

                System.out.println("\nTweets containing '" + input + "':");
                while (rs.next()) {
                    System.out.println(rs.getString("username") + ": " + rs.getString("text"));
                }
            } catch (SQLException e) {
                System.err.println(e.getMessage());
            }
        }

        scanner.close();
    }
}
```

이제 `TwitterStreamApp`을 실행하여 트윗을 실시간으로 스트리밍하고 저장하기 시작합니다. 별도의 터미널 또는 명령 프롬프트에서 `TweetViewer` 클래스를 실행하여 저장된 트윗을 보고 필터링합니다.

이 예제는 교육용으로만 제공되며 운영 환경에서 그대로 사용해서는 안 된다는 점에 유의하세요. 특정 요구 사항에 따라 예외를 처리하고, 보안을 개선하고, 성능을 최적화해야 할 수도 있습니다.